Skip to main content
skill CX Codex

qstart · ai4xe, deepseek-harness — Claude Code skill: what it does and how to install

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.

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 qstart does

qstart records requirements and guides a discussion from initial intake to a shared task overview. It distinguishes infra tasks, which do not change a version, from versioned hotfix tasks. When no mode is specified, it infers one from the full request. The default execution tier is solo; adding team activates an orchestrator and an independent executor subagent.

The skill creates a project discussion record from templates/discussion.md. It checks for applicable instructions in local/LOCAL.md and reuses them. An accepted option or a completed discussion does not authorize execution; hand-off requires an explicit qgo.

It operates with the current workspace permissions. If Windows prevents a command from capturing child-process output, qstart calls for a same-process test instead of elevated permissions, and does not report that alternative invocation as success of the original command.

What it helps with

  • record requirements for a development task
  • classify work as infra or hotfix
  • agree on a complete task overview before execution
  • choose solo or team for the execution hand-off

Example prompts for the agent

  • Run qstart and help me work through this task's requirements.
  • Start a hotfix discussion for the current project; the target version is 2.0.1.
  • Run qstart team and prepare the overview before qgo.

How to install qstart

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 qstart -a claude-code

3Manually: put the files in place

~/.claude/skills/qstart/SKILL.md

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

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

Questions about qstart

How do I install qstart in Claude Code?

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

What does qstart do?

It gathers requirements, researches the task, and guides a discussion toward an agreed overview. Execution waits for an explicit qgo.

What does qstart need to work?

It uses templates/discussion.md and the current workspace permissions. Applicable instructions in local/LOCAL.md are reused.

Source text

SKILL.md · MIT
---
name: qstart
description: "Wish / Parallax — development discussion entry: intake → focused research → round-by-round alignment → complete overview, then wait for explicit qgo once Q-Go Ready. Chinese triggers: 许愿创造, 许愿编程. Supports infra (non-version) and hotfix (version) tasks; bare qstart infers from the full requirement, not infra by default. Default tier: solo direct execution; team enables orchestrator + executor; aliases ver/version/nover. Trigger words: qstart, Q development discussion."
whenToUse: The user wants to start a development discussion, record requirements, or discuss an infra or hotfix task, or explicitly mentions qstart / Q development discussion.
user-invocable: true
metadata:
  portable: true
  version: 2.0.1
  display_lang: en
---

# qstart — Development discussion

The goal is to save the user time and effort: establish the facts first, then discuss judgment, and proactively drive to a complete "big-picture understanding" through concise, plain-language exchanges; then wait for the user's qgo or an explicit hand-off. A finished discussion or an accepted option is not execution authorization.

This skill ships its own full discussion protocol and `templates/discussion.md`; do not read or invoke other discussion/hand-off skills to fill in the logic. The later qgo stage reuses shared capabilities such as bcheck, gclear, rcheck, and xwrap; this skill creates no locks or workflow state machine. Before use, check whether the skill has an applicable `local/LOCAL.md`; if so, reuse and adapt it first.

**Self-path references**: when this skill is loaded the harness provides a `Base directory for this skill: <path>` sentence; references to templates and files in this directory must build relative paths from that sentence's path, and absolute paths must never be hardcoded.

**Permission and test boundary**: the whole chain uses the current normal workspace permissions; do not request wider permissions, full access, extra add-dir or profile changes because a tool failed. Windows named-pipe limits may make commands that capture child-process output report `spawn EPERM`; choose a same-process test that keeps all assertions and real output (e.g. Node's `--test-isolation=none` or directly executing a `node:test` file), inherit stdio or file output, do not retry with escalated permissions, and do not misreport an alternative invocation as the original command succeeding. If there is no equivalent verification within normal permissions, report the platform limitation truthfully; do not skip verification or falsely claim completion. Write the actual test commands and permission boundary into the discussion for qgo and the independent reviewer to follow.

## 1. Identification and cheap recording

- Use the current Git root as the root directory; in a non-Git environment use the current directory. Resolve paths relative to the root and do not assume a sub-project layout. Distinguish host/Git root, task root, document directory, actual version source and sync points, and commit prefix. Without a project name, use the current project; with a name, locate it yourself. When ambiguous, ask a single question first with a sensible default; never silently guess the project.
- `infra` means a non-version task; `hotfix` means a version task. Explicit parameters and the user's latest explicit instruction take precedence. A bare qstart decides from the full requirement and project conventions; do not default to infra and do not repeatedly ask for the type during intake. When information is insufficient, mark it as "to be decided from the full requirement". Map aliases by word, order-independent: `ver`/`version` → hotfix, `nover` → infra, `team` → full execution-tier chain (see next item). Always persist and document the canonical names (infra/hotfix, solo/team).
- Execution tier is **solo by default** (after independent bcheck and native gclear, execute directly in the same window, same SID/agent, with no hidden orchestrator or separate executor session). Only the explicit keyword `team` uses the same-window orchestrator + independent native executor subagent full chain: `team` appearing anywhere in the invocation arguments (mode and tier are orthogonal; order is irrelevant), or the user explicitly saying team before the hand-off; a verbal switch mid-session after a bare qstart start is equally valid (window = before the qgo hand-off). The literal `solo` is retained as an "explicit default declaration" and is harmless. Write the tier into "Identification result" for qgo.
- During intake, only record cheaply; do not conduct deep investigation to identify the project/version. Before the task type is settled, record in a temp directory permitted by the host; once identification is sufficient, persist to the path below. When migrating, keep the original intake content and update references; do not create a parallel document system.
- The first receipt briefly lists: mode (explicit/to be decided), infra timestamp or the known hotfix target version, target project, execution tier (solo/team, default solo), `grill-me: on/off` (default on), and the current record path. If the type is undecided, do not invent a version. Confirm the final identification once in the overview so the user can correct it.
- Initialize the record with `templates/discussion.md` from this directory. Default paths once the type is determined: infra → host `docs/dev/infra/infra-discussion-{timestamp}.md`; hotfix → host `docs/dev/hotfix/v{target-version}-discussion.md`. If the target project has an explicit document convention, follow it and record accurate anchors.
- Probe the actual hotfix version source inside the task root (e.g. pyproject.toml, package.json and their sync points); the target defaults to PATCH+1, and an explicit user instruction takes precedence. For independent tag tasks without a real version, use "tag-timestamp" and do not invent a version source. Resolve uncertain versions during alignment.
- If the file exists, first verify ownership: continue the same task; preserve other tasks' files; choose a project/task suffix that still matches the original naming glob and record the exact path; never treat the same version alone as the same task. Create missing directories.
- Put personalized instructions appended at the call tail or during the process into "Special notes for this run"; they stack on top of the core protocol and do not replace stage gates.
- Reply along the current session channel: if this round's message comes from an instant-messaging integration, reply along that channel; otherwise use normal session text; do not duplicate across channels. Display language priority: trigger-message language > explicit user instruction (e.g. "use English" takes effect immediately) > this file's frontmatter `metadata.display_lang` default; for a bare command with no language signal, use it as the default display language.

## 2. Three-stage protocol

### Intake

For each message, only record and briefly acknowledge — **no structuring, no plan, no deep dive, no research** — until the user explicitly signals the end, e.g. 「没有了」 (a typical Chinese end-of-input signal; judge by semantics in general and do not add equivalents for other languages). Invoking qstart itself is not an end signal. If the user has explicitly finished, do not ask again.

### Focused research

Briefly announce that research is starting. The main session orchestrates, concentrates necessary research, and may flexibly arrange background research (e.g. this harness's subagents); enough depth to judge the direction is sufficient. Research tasks must have real result collection and exception handling; do not just launch them and assume completion. Record facts, evidence, open questions, and necessary anchors in the discussion record.

- During research, run one cheap check for `git` (e.g. `git --version`). If Git is missing, raise it as one alignment question: state that without Git follow-up tracking and saving may be affected and ask whether the user wants to install it; do not block and do not check at trigger time.

Resolve facts that can be found from code/files/live services yourself; reserve preferences and value judgments for alignment. Do not open a formal plan or enter bcheck. Do not dump a question list on the user.

### Round-by-round alignment

- Ask one question at a time, with 2–4 options, a clear recommendation, and a brief reason; plain and concise, no long essays; the user controls the pace. Prefer text-based multiple choice.
- In each round, work through the questions that need user judgment in dependency order; do not switch to fragmented research after each answer. When new facts are needed, first collect the round's questions, research them together, then move to the next round; multiple rounds are allowed.
- grill-me is on by default: check judgments systematically along an upstream→downstream decision tree, resolve dependencies first, and do not ask the user about branches you can check yourself. Do not interrogate for its own sake or sacrifice the time-saving goal.
- If the user verbally asks to turn grill-me off, turn it off and record it; still research normally and align thoroughly without lowering quality; do not add a toggle file.
- Decide technical details that need no user choice yourself; do not invent questions to fill rounds. Do not stop mid-way without reason and make the user prod you to continue.

## 3. Complete overview and hand-off boundary

Once research and round-by-round alignment are sufficient, proactively present the complete "big-picture understanding" and write it into the record:

- Task type is explicitly infra (non-version) or hotfix (version); for hotfix give the actual target version, version source and sync points.
- Goals, scope and non-goals, key decisions, completion criteria, open risks, personalized notes.
- host/Git root, task root, document anchors and commit ownership; a single project may be described together without repeating paths.
- The next step is only **qgo or an explicit user hand-off**, i.e. **Q-Go Ready**, not reviewed or executed. The overview does not replace prior user alignment.

**HARD-GATE: before the user explicitly says qgo / "the direction is fine, hand it off", do not write a formal root-cause/plan document, do not enter bcheck, and do not touch code or deploy.** A finished discussion, no new questions, an accepted option, or choosing the Q route does not cross the gate. Wait for authorization after the overview; if the user corrects something, update the discussion and overview and do not silently switch type. After an explicit hand-off, hand over to qgo without asking the user to confirm again.

© AI4XE · MIT · AI4XE/Parallax

Similar skills

SKILL.md skills catalog →

qstart by other authors comes first.

qstart AI4XE 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 find-skills vercel-labs find-skills is a Claude Code skill that locates agent skills for a task and helps assess the results. It activates when someone asks for a capability that may already be installable. CX Codex +1 4,400,000installs frontend-design official anthropics The frontend-design skill guides intentional visual design for new interfaces and redesigns. Use it when a generic generated UI is not enough. CX Codex +1 1,025,790installs agent-browser vercel-labs This Claude Code skill automates browser interaction for tasks like navigating sites, filling forms, and testing web apps. It also supports exploratory QA and Electron app automation. CX Codex +1 1,600,000installs design-taste-frontend Leonxlnx The design-taste-frontend Claude Code skill sets design rules and checks for websites. It activates for new pages, redesigns, and requests to fix a generic-looking site. CX Codex +1 802,600installs grill-me Matt Pocock grill-me interviews you about a plan or design to expose gaps and sharpen decisions. Use it before implementation starts. CX Codex +1 1,424,476installs grill-with-docs Matt Pocock The grill-with-docs skill interviews you about a plan or design and creates ADRs and a glossary along the way. Use it when decisions need sharper definition. CX Codex +1 1,219,756installs

From the same set19

The whole set →
qgo 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. 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 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 rcheck rcheck — a skill for Claude Code checks completed work against a plan and an implementation summary. It runs after a complex task or when asked to review completion. CX Codex +1 ★ 136repo stars xwrap xwrap is a Claude Code skill that checks a repository, updates task lists, and records a development wrap-up. Invoke it with xwrap or wrap up. CX Codex +1 ★ 136repo stars

Project sponsors

Companies that keep this analytics open