Skip to main content
skill CX Codex

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

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.

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 completion criteria and sends it through an independent bcheck review. Work proceeds after a PASS≥4 result, followed by a hand-off for execution in the same window. Solo execution is the default; an independent executor subagent joins when the user selects team mode.

The executor handles implementation checks, commits, xwrap, and the completion receipt. Infra and hotfix use the same rcheck stage. The skill requires the parallax_handoff tool, the safe-point hook from the complete native bundle, the harness's native subagent capability, and the bcheck, gclear, rcheck, and xwrap skills. The hand-off is unsupported without these components.

What it helps with

  • turn a development discussion into a plan with completion criteria
  • get an independent review of the plan before execution
  • hand an agreed task to an autonomous executor
  • assign implementation checks and a completion receipt

Example prompts for the agent

  • Hand off the discussed development task with qgo.
  • The direction is approved; pass the work to an executor.
  • Run qgo for this task.

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 an approved discussion into a plan, gets that plan reviewed independently, then hands the work to an autonomous executor. The executor handles implementation checks, commits, and the completion receipt.

What does qgo need to run?

It requires parallax_handoff and the safe-point hook from the complete native bundle, the native subagent capability, plus the bcheck, gclear, rcheck, and xwrap skills.

Source text

SKILL.md · MIT
---
name: qgo
description: "Q workflow hand-off execution: re-check the discussion → plan → independent bcheck → same-window gclear → same-window autonomous execution (solo by default), or an orchestrator supervising an independent native executor subagent (explicit team). infra/hotfix share rcheck; the executor owns verification, commits, xwrap and the final receipt. Trigger words: qgo, Q hand-off development."
whenToUse: After a Q discussion the user explicitly says qgo / hand off development / the direction is fine, authorizing the discussion to be turned into a reviewed plan and executed autonomously.
user-invocable: true
metadata:
  portable: true
  version: 2.0.1
  display_lang: en
---

# 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, templates and read-only helpers; do not read other discussion/hand-off skills or host-private scripts to fill in the logic.

Runtime prerequisites: the `parallax_handoff` tool and safe-point hook provided by the complete native bundle, this harness's native subagent primitive, and the shared bcheck/gclear/rcheck/xwrap skills (reachable in the same skill directory or the user-level skill root). skills-only is not equivalent; when the native hand-off capability is missing, explicitly report that it is unsupported and point to the complete bundle — do not substitute a normal compact or another session, and do not work around it via bypass, add-dir or configuration edits. Before use, check whether the skill has an applicable `local/LOCAL.md`; if so, reuse it first. Display language priority: trigger-message language > explicit user instruction (e.g. "use English" takes effect immediately) > frontmatter `metadata.display_lang` default.

**Self-path references**: when referencing templates and scripts in this directory, build relative paths from the `Base directory` sentence the harness provides at load time; never hardcode absolute paths.

**Full-chain permission budget**: use the user's current normal workspace permissions, and write them and the actually runnable test commands into the plan, carrier and the brief given to the executor/independent reviewer. Do not request wider permissions, full access, extra add-dir or configuration changes because of a failure. On Windows, a named-pipe-induced `spawn EPERM` when capturing child-process output should be replaced by a same-process test that keeps the same assertion set and real output (e.g. Node `--test-isolation=none` / directly executing a `node:test` file), inherited stdio or file output, without retrying with escalated permissions; keep evidence for both the original failure and the equivalent invocation. If there truly is no equivalent verification under normal permissions, report the limitation — do not skip testing or falsely claim the original command passed.

**Core design constraint**: the native hand-off management tool is visible and executable only to the top-level agent; the solo top-level executor and the team orchestrator may use it, and the team executor subagent does not gain control of its own session. Subagent lifecycle (interrupt, continuation, succession) is managed exclusively by the orchestrator through the native subagent control tools. The executor is only responsible for doing the work, writing the hand-off note, writing the completion receipt and finishing its turn normally; do not feed the management tool or operational details to the executor. Lightweight first: do not build heavy machinery for the last 1%.

**Intent clause (resist silent degradation to platform defaults)**: the executor and the solo session hold the same **task tool surface**, **including the right to summon subagents** (a core mechanism for context economy and parallel speed; team ≠ reduced rights); top-level-only management tools are not part of the task tool surface. rcheck's independence comes from the **fixed review procedure + a freshly spawned subagent with zero inherited context**, and is not harmed by "who holds the summon button" — an executor dispatching its own independent reviewer is the original design, not a degradation. The standard native bundle configures the subagent service with `maxDepth=3`; if the environment still refuses to let the executor summon subagents, report it truthfully and point to a supported complete bundle — do not hand-edit configuration or silently degrade to self-review.

## 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, host/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. If the directory does not exist, create it with `mkdir -p`. 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, protection of existing dirty state, risks, **independent rcheck before commit**, executor-side xwrap, **reference context** (for a clean session), and the boundary of **executor lifecycle owned exclusively by the orchestrator**. Put necessary differences in task material; do not copy the whole plan into a template.
4. Invoke **bcheck** as a 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 gate skills.

## 2. Top-level session same-window hand-off

After an independent bcheck with PASS≥4, **solo and team, Web and other native entry points all actually run gclear**; do not skip it. Refine the hand-off with the approved plan, exact anchors, user decisions, current stage, identity/recovery state and necessary environment; the carrier must already exist in the calling agent's workspace — when a cross-repo task root is outside that workspace, save the state in a permitted temp directory of the calling workspace. Do not copy the full planning history.

- **solo**: the hand-off material references the exact path of `templates/solo.md`; after taking over in the same window, same SID/agent, the current session acts directly as the executor, and the user can always append requirements along the original window, with no hidden orchestrator or background successor.
- **team**: the hand-off material references the exact path of `templates/orchestrator.md`; after taking over in the same window, same SID/agent, it is still the orchestrator. Save the existing executor id/state, orchestration records, completion/handoff and heartbeat ownership; the first turn verifies any existing executor first and, if present, resumes supervision without duplicate dispatch.

Call `parallax_handoff` per the gclear tool contract: `operation_id` is required, `action=request` is the default; for a request, `summary` and `continue_with` are both required and together ≤12000 characters, and `carrier` is optional. Write that id and the role template/carrier anchors into the continuation instruction; a normal acceptance returns `state=requested,durable=false,intent_durable=true`: **only the pre-intent is durable; the current tool result has not been appended and nothing has been applied** — this is not a failure, do not retry, and do not require requested+durable=true. End the current tool turn; the safe point flushes the native tool result first and then replaces the surface; the next model turn resumes automatically, preserving the transcript, new user input, subagent notifications and parent-child relationships, without waiting for the user to "continue".

On the first turn after the hand-off, verify with `action=status` for the same id, **and never send another request instead of querying**. Only `applied,durable=true` is a hand-off with confirmed durability; `failed` means the old surface is preserved; `applied,durable=false` means the surface changed but durability is unconfirmed — keep the carrier/id, report truthfully and query for acknowledgement, and never clear again. If a request has not been applied and needs to be withdrawn, use `action=cancel` with the original id and verify; if the receipt is missing or after restart recovery, also query the original id first — do not create a new SID or repeat the request.

This is the **top-level session's own hand-off**, separate from the team executor's succession: the executor does not call this management tool and does not receive this section's operational details. Later self-refreshes still follow the same gclear protocol; a normal compaction does not replace this step.

## 3. Independent executor (team tier)

Combine the full content of `templates/executor.md` with a **redacted task brief** (task and scope, checklist, acceptance criteria, mode/version source, root and artifact contract, exact executor and orchestrator identities, current task, allowed commit scope, completion and handoff paths, environment notes) into a **subagent start prompt**. Do not feed the full orchestration plan containing lifecycle and mechanism sections. The executor is the one doing the work, not a monitor.

- **Start**: use this harness's **subagent tool** to spawn an in-process executor subagent (`prompt` = the complete prompt above; `cwd` = task root). Record the returned subagent id in the orchestration record (`<task root>/tmp/qgo/executor-<ID>.md`, including id, start time and a one-sentence task description).
- The executor autonomously completes: implementation → real-environment verification → independent **rcheck** as a skill (PASS≥4; fix and re-review issues; the review subagent is spawned by the executor itself — fresh context with zero inheritance; see the intent clause for independence) → scoped local commit → **xwrap** as a skill to finish todo/wrapup and its necessary commits → the final receipt written to the orchestrator-provided `completion-<QGO_EXECUTOR_ID>.md`. Skip xwrap only on an explicit user opt-out, and state that in the receipt.
- When invoking xwrap, specify the exact host/Git root, task root, mode/actual version source, discussion/plan, and this run's artifacts/hunks, so it does not mix in other tasks through its default root or whole-file adds. On continuation, inject the commit candidate list; all of xwrap's ask-user branches (Step 1, Step 4, Step 6, 7.2, 7.3, 7.4, 7.5) are decided autonomously by the executor according to the injected contract and hand-off notes without waiting for the user, and each decision and its rationale is listed in the receipt.
- **Receipt contract**: `completion-<ID>.md` exists and contains: task identity, latest requirements, rcheck/wrapup anchors, all actual commits, test conclusions, xwrap branch decisions, deviations/not done/outstanding verification.
- Hand-off duty: when the orchestrator asks for a refresh, the executor first finishes up or reaches a stage completion point; write "everything necessary and required to continue the task" to the fixed note path; make a handoff checkpoint commit and put the SHA in the note; reply `READY-FOR-HANDOFF <SHA>`. If unsafe, continue rather than force a hand-off.
- Executor-visible text must not contain termination/clear mechanism names or operating methods, nor a list of prohibitions; constraints are enforced by the orchestrator template and lifecycle management. **Do not disclose context percentages, thresholds, monitoring or self-check details.**

## 4. Session primitives and isolation

This directory's `scripts/session.mjs` provides read-only identity/process corroboration (run with dsh's bundled Node): `identity` (cwd session directory, session id, active dsh processes, `session_processes` filtered by `--session-id`), `idle` (a process-level idle approximation, unsuitable as a criterion on a long-running Web host). `scripts/context.mjs` read-only parses the most recent usage records under `$DSH_HOME/sessions/`, with multi-frame zstd decoding handled by the script; reading a subagent session must pass `--session-id` (its directory name is a bare UUID without the `session-` prefix), and the top level also passes the verified id explicitly rather than guessing ownership from the latest session. Neither controls processes or decides hand-off/completion; old usage alone cannot prove the surface was replaced. **The executor subagent's live state is governed by the orchestrator's own subagent control tools** (`list_agents`/completion notifications/`send_message`); the scripts are only corroboration. When Node is unavailable or a script errors, fall back to the harness UI's native "context used N%" display or an equivalent read-only source, and state the corroboration source truthfully. Native hand-off verifies durability by operation status and the actual context by valid model input/meter; corroboration is not a substitute.

- **Node resolution chain (in order; use the first that succeeds)**: ① `node` on PATH; ② `"$DSH_HOME/../node/bin/node"` (Linux/macOS); on Windows use `"$env:DSH_HOME\..\node\node.exe"`. Do not depend on whether `DSH_ROOT`/`DSH_WIN` exist. If none is available → truthfully report "Node unavailable" and fall back to the UI; do not do so silently.
- **Invocation**: `node <this skill dir>/scripts/context.mjs usage --cwd <task root> [--session-id <ID>] [--window-tokens N]`; `node <this skill dir>/scripts/session.mjs identity --cwd <task root> [--session-id <ID>]`. Both scripts support `--self-check` (outputs `platform/node/backend/zstd/dsh_home/canonical_cwd`).
- **Process backend**: Linux `/proc`, macOS/BSD `ps -axo pid=,command=`, Windows PowerShell CIM (`Win32_Process`); when enumeration is unavailable report `null` (unknown) and never falsely report idle.
- **Cross-platform permissions**: native hand-off does not start another shell/DSH and does not change the SID; Windows, Linux and macOS use the same tool protocol and normal workspace permissions, with no extra directory access, temporary environment-variable changes or permission elevation required. When the native capability is unavailable, state that it is unsupported and do not edit configuration to work around it.
- **Tests**: tests are available only in the development repo and are excluded from published artifacts (the bundle build strips tests/).

- **Isolation**: the executor is an in-process subagent, naturally disconnected from the user message channel and not inheriting the orchestrator's conversation context; the start prompt explicitly states "user communication is the orchestrator's responsibility". Do not read or borrow other projects' credential files; redact the brief before feeding it.
- **Identity record**: after start, write the subagent id, start time and task-start HEAD (`git -C <root> rev-parse HEAD`) to `<task root>/tmp/qgo/executor-<ID>.json`. Continuation/recovery is based on the record.
- **Termination semantics**: only interrupt the current turn of an executor subagent whose identity has been verified, using `interrupt_agent`; never terminate the orchestrator's own process or an unrelated session.

## 5. Orchestrator supervision in practice (team tier)

Immediately after start, establish a supervision arrangement: this harness's subagent completion notifications are delivered proactively (the subagent pushes messages to the orchestrator at each turn boundary), and the orchestrator also periodically verifies status with `list_agents` (scope `children`), recording checkpoints, ownership and the next check in the orchestration record. Saying "I will check periodically" alone does not count as establishing it.

- **On-demand + periodic checks**: 10 minutes is only a general reference; adjust dynamically with risk, stage and signals. Handle executor messages substantively as soon as they arrive; for a long silence (no messages and `list_agents` shows running but there is no artifact progress), use `send_message` to ask for progress.
- **Completion awareness (G6, proactive delivery)**: a subagent completion notification **automatically wakes an idle orchestrator into a separate new turn** — this is built-in platform behavior; no polling is needed. Multiple wake-ups are normal (the completion notification and the wrap-up message each wake it): on every wake-up, first check the orchestration record for new information, handle idempotently, and do not repeat reports or dispatch.
- **Periodic heartbeat (G7, schedule self-built)**: at task start, use `schedule_create` (target=`this_session`) to create a heartbeat task (interval on the order of 10 minutes, adjusted to task risk; title carries the `qgo-heartbeat` marker), prompt = "Heartbeat: briefly report current progress and next steps to the user; inspect the executor (`list_agents` status, artifact growth); for a long silence use `send_message` to ask; if everything is normal, one sentence is enough". Heartbeat turns are **idempotent**: if there is no progress, say so briefly and do not invent progress. Immediately after task delivery, use `schedule_edit` to delete the heartbeat task, leaving no dangling delivery.
- **Idle awareness (G5)**: a heartbeat turn is a checkpoint — verify the executor's status with `list_agents` (scope `children`); `running` but silent for a long time with no artifact progress → ask via `send_message`; if two consecutive asks get no response, treat it as an anomaly (report truthfully to the user and, if necessary, handle it per the refresh flow).
- **Executor context and refresh ladder (G3)**: the orchestrator reads read-only corroboration from the executor's session log (usage records and compaction events in that executor's directory under `$DSH_HOME/sessions/`; `scripts/context.mjs` can help parse; if the window is unknown, fall back to 1,000,000 tokens). Ladder: the executor's **first automatic compaction event → watch** (record in the orchestration record); **a second compaction or usage over 60% → arrange a refresh** (see below), usually not beyond 70%. Refresh is an orchestrator-exclusive action; the executor has no awareness obligation.
- **Executor refresh (hand-off)**: remind the executor to finish up or reach a stage completion point → verify its hand-off note exists, `READY-FOR-HANDOFF <SHA>` and the checkpoint commit at HEAD → confirm the old executor has finished that turn; if still running, verify identity first, confirm a safe point, then `interrupt_agent` and verify it has stopped writing → use the native subagent tool to spawn an **independent new executor subagent** (executor.md + hand-off note + **commit candidate list** (`git log --oneline <task baseline>..HEAD` + `git status --porcelain` list) + "continue from the next step; do not redo completed items"). Update the new id in the orchestration record; never let two executors modify the same task concurrently, and never substitute a shell/background process for a native subagent.
- **Safe point first**: when the executor judges it is not a safe point, it may continue; the orchestrator waits and reminds later, never forcing a hand-off.
- **Mid-course user adjustments**: first update the existing task body, then convey them accurately via `send_message`; verification, commits and the latest receipt must cover the new requirements. Disclose failures, deviations, skips and outstanding verification transparently.
- **Orchestrator's own context**: persist orchestration state at key points; when another refinement is needed, hand off in the original window per §2 and gclear, preserving existing subagents and heartbeats; after taking over, first query the original operation status, then verify the executor. Heartbeat turns also self-check that the state file is in place; a normal auto-compaction does not replace gclear.

## 6. Delivery, follow-up changes and reclamation

The final receipt is bounded by the executor completing xwrap (or an explicit user waiver) and necessary commits; it is not replaced by a business commit, a settled subagent or a completion filename. The orchestrator reports the real result to the user and does not take over project wrap-up.

- **Delivery means acceptance**: once `completion-<ID>.md` exists and contains the xwrap result and commit list → the orchestrator verifies it (commits in the log, key verification evidence reproducible) and delivers to the user; if the receipt is not yet written, use `send_message` to remind it to finish and do not deliver.
- **Follow-up changes and recovery**: for new adjustments, prefer `send_message` to an executor that can still continue; if it has settled, spawn a new executor subagent per its hand-off note (inject the commit candidate list) and do not redo completed items. Reclamation does not delete history; unfinished tasks continue.
- **Top-level recovery**: restore the original SID/agent through the harness's normal entry point; do not open a separate successor session and do not open the same session concurrently. First query `parallax_handoff(action=status)` by the recorded operation_id and do not resend the request; if applied, just continue; if durability is unconfirmed, keep the carrier and evidence and report truthfully, without clearing again. For team, then verify the existing subagent/heartbeat status before resuming supervision; process enumeration or old usage is not proof of a successful hand-off.

## 7. solo tier (default) and team tier (explicit full chain)

Execution tier is **solo by default**; only the explicit `team` keyword (carried in qstart/qgo invocation arguments, or explicitly stated by the user before the hand-off) uses the full orchestrator + executor chain; mode and tier combine orthogonally.

**solo**: flow §1 as usual (independent bcheck PASS≥4 is not skipped); §2 actually runs native gclear, with the carrier referencing `templates/solo.md` (executor role, no orchestrator). After the safe point the **original window, same SID/agent** takes over automatically and the current session executes directly; the user continues to append requirements in the original window, new input enters the continuation, and nothing is hidden in the background or moved to another user channel. Thereafter skip §3's orchestrator assembly, all of §5 (supervision) and §6's orchestrator acceptance, and work straight through per solo.md to delivery.

Wrap-up follows executor discipline: implementation → real verification → independent rcheck (PASS≥4) → scoped commit → xwrap → the final receipt **delivered directly along the current session channel**, without a completion file; after finishing, end the turn normally.

solo has no supervision or context observation: when the task is expected to be heavy or clearly grows mid-way, tell the user honestly and suggest switching to the team full chain rather than forcing it through.

© 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 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 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 jupyter-notebook-writing zc277584121 jupyter-notebook-writing — a skill for editing Jupyter notebooks in Markdown instead of JSON. Runs on Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode; edit .md files first, then convert to .ipynb using jupyter-switch. CX Codex +1 3,900installs ui-designer daniel-dan-conrad ui-designer — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that produces deployment-ready interfaces built around a deliberate visual direction. CX Codex +1 3,700installs domain-context ryan-price domain-context maintains a domain knowledge base in .tasks/domain.md across sessions. Tracks internal terms, entity relationships, and core business rules. CX Codex +1 2,700installs customware-support-widget customware-ai customware-support-widget wires the Customware support chat into a client-only React Router SPA: script in root.tsx, <customware-chat> in the route or layout that needs it. CX Codex +1 2,600installs frontend-design-ui-ux ulpi-io The frontend-design-ui-ux skill creates a locked design language and UX/UI specification for a feature or screen. Use it before handing the build to an engineering agent. CX Codex +1 2,500installs mm2-analytics-dashboard-roblox reason-machines mm2-analytics-dashboard-roblox — a Claude Code skill for tracking Murder Mystery 2 inventory, win rates and strategy patterns. Ships Python scripts and a Python API, with exports to JSON, CSV or an HTML dashboard. CX Codex +1 2,400installs

From the same set19

The whole set →
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 rcheck This Claude Code skill reconciles a complex task’s implementation with its plan and summary. It runs after multi-step work, before the result is reported, or on an explicit rcheck request. CX Codex +1 ★ 136repo stars xwrap This Claude Code skill checks a repository, updates task tracking, and writes a wrap-up report. Invoke it with xwrap or a request to wrap up the task. CX Codex +1 ★ 136repo stars bcheck bcheck — a skill for Claude Code that independently reviews analyses and development plans. Run it after a document is prepared or when a review is requested. CX Codex +1 ★ 136repo stars bcheck This Claude Code and Codex skill sends analyses and plans for an independent review. It runs after a document is prepared, before the user gets a response, or when asked for bcheck. CX Codex +1 ★ 136repo stars bcheck The bcheck Claude Code skill independently reviews root-cause analyses and development plans. Run it after a document is ready and before reporting back, or when a plan review is requested. CX Codex +1 ★ 136repo stars qgo 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 parallax The parallax Claude Code plugin turns a wish into a plan with independent review. It discusses the task, hands it off for execution, then audits the result. ★ 136repo stars

Project sponsors

Companies that keep this analytics open