skills

Fix a bug end-to-end through a live Comment.io worklog comm — reproduce, write a regression test that fails first, fix, verify on the preview, and drive to a merge-ready PR, with the repro, root cause, and verification recorded as the decision history. Invoke explicitly as `$comment-bug` / `/comment-bug`, or when a task is a defect, regression, broken workflow, or user-visible failure to be reproduced and fixed with a watchable, steerable record. Replaces the retired bug skill. Works identically under Codex and Claude Code.

Deliver a feature end-to-end through a live Comment.io worklog comm — plan, request review points, design, review-loop the plan, implement while listening for human steering, and drive to a merge-ready PR. Outputs a merge-ready PR plus a decision history, a non-technical feature design, and (for architecture-level changes) a proposed architecture decision record, all as comms. Invoke explicitly as `$comment-feature` / `/comment-feature`, or when asked to build/add/implement a feature with a watchable, steerable record. Replaces the retired feat + feature-dev. Works identically under Codex and Claude Code.

Give this agent session a named, session-scoped Comment.io identity instead of writing as faceless anonymous. Runtime-generic (Claude Code, Codex, any shell agent). On the session's FIRST write to Comment.io, lazily mint ONE ephemeral "ephemeral" handle (@owner.e-xxxx) bound to this session, then write/comment as that handle so the work is attributed and @mentionable. A primitive the generic comment skills (comment, worklog, comment-feature, comment-bug, ...) invoke before its first write. The generic `comment` skill points here; invoke when an agent is about to create/edit a comm or post a comment, especially for live worklogs and delivery tasks, even if registered profiles exist. Mints over EITHER a paired computer (the daemon's own token — native, or a Docker-caged daemon via `docker exec`; no key to copy) OR the owner's ark_ key; degrades to anonymous when neither is available. (Pairing enables identity for the paired host's origin; a different origin still needs an ark_ key.) Works the same under Codex a

Initialize or refresh a repo for the `comment-*` skill family. Two layers: (1) the **repo config the skills read** — the `AGENTS.md`/`CLAUDE.md` "Agent Skill Config" pointer plus `docs/TESTING.md` (the affected-test lane for iteration, pre-push, PR creation, and merge-ready gates), inferred from the repo's build/test setup; and (2) the **architecture docs as comms** — one living "Architecture Overview" comm plus immutable per-decision ADRs in a Team Wiki folder. Idempotent — re-running reconciles existing files/comms instead of duplicating them. Trigger on "set up comment-init / the comment skills for this repo", "set up the testing config", "set up the architecture doc", "get my architecture", "document the architecture", "write an ADR", or "update the architecture overview". Works identically under Codex and Claude Code.

Shape a raw feature idea into a crisp PM-level spec through a live Comment.io comm, then hand it to comment-feature to build. Nails the goal and success definition, fits the idea to the app's existing concepts, minimizes new user-facing concepts, and runs a self-checking shaping loop that surfaces the risks in the current plan plus ways to address each — so a human can decide how much to iterate before spending engineering time. Forms a falsifiable hypothesis, checks the implied problem against whatever analytics system the codebase uses, and specs the metrics that would prove the hypothesis right or wrong plus a feature-level dashboard to track them. Blocks on goal-level questions and on a final "build it?" go-ahead, then invokes comment-feature. Invoke explicitly as `$comment-spec` / `/comment-spec`, or when asked to spec, shape, scope, or design a feature before building it. Works identically under Codex and Claude Code.

Drive a pull request to merge-ready — running exactly one official code review (auto-detected: prefer Codex, fall back to Claude Code), confirming CI, review, and approval. **Stops at merge-ready by default**; only enqueues into the merge queue, watches the merge, and cleans up the worktree when the user EXPLICITLY asks to land/queue/merge. Posts each state transition to the task's worklog comm when one is provided. Replaces the retired pristine + land — the single PR-lifecycle skill. Invoke as `$ship` / `/ship`, or when asked to finish, land, merge, make a PR mergeable, or "make it pristine". Works identically under Codex and Claude Code.

Keep a human in the loop on a running task through a Comment.io comm. Poll the task comm for new @mentions and replies, fold human steering into the work mid-flight, and escalate by @mentioning a human and waiting when a decision shouldn't be made alone. Use during any long-running or autonomous task that has a worklog comm. Trigger when asked to "listen for steering", "check for comments", "escalate to a human", or whenever you need a human decision before continuing. Works identically under Codex and Claude Code.

Open and maintain a live Comment.io "worklog" comm as the shared working memory for one unit of work — a comm mirroring the plan, status, decisions, executive summary, and open questions, kept in sync as work proceeds. Other skills (comment-feature, comment-bug) call worklog to create and update the task comm. Use ONLY when explicitly asked to "open a worklog", "track this in a comm", or "give me a live status doc", or when a delivery skill (comment-feature / comment-bug) calls it — NOT automatically for routine local, read-only, or investigative work, and not when no Comment.io credentials are configured. Works identically under Codex and Claude Code.

Make a small or exploratory change FAST and show it, so you can look before committing to the merge-ready gate. Implements quickly, runs only the repo's affected-test lane (or nothing for a pure visual tweak), and surfaces the result in the real app — deliberately skipping the `review-loop` gate and the PR. When you like it, it promotes the work into `comment-feature` / `comment-bug` to harden and ship. Invoke as `$comment-prototype` / `/comment-prototype`, or when asked to "just try", "quickly tweak", "spike", "prototype", or "let me see X first". Works identically under Codex and Claude Code.

Drive a multi-phase plan to completion autonomously — ideally a Comment.io "Plan" comm (falling back to a local Markdown plan file) as the living source of truth. Implements each phase, validates locally and on staging where possible, keeps the plan in sync, runs `$review-loop` at phase boundaries, and steers to a human when a decision shouldn't be made alone. Composes worklog/steer/review-loop and is the execution engine `comment-feature` delegates to. Invoke as `$drive-plan` / `/drive-plan`, or when asked to execute a phased plan autonomously. Works identically under Codex and Claude Code.

Review a change (a code diff, a plan, or a PR) with a panel of independent review subagents and loop — fix the real findings, re-review with a fresh panel — until a full panel comes back with nothing actionable. The local, pre-PR "iterate until clean" gate the delivery skills run at plan and phase boundaries. Distinct from `code-review`, which posts one official review to a PR; `review-loop` is the in-flight convergence loop. Only invoke when explicitly requested as `$review-loop` / `/review-loop`, or when a delivery skill calls it. Works identically under Codex and Claude Code. (Formerly `3wise`.)

The front door for engineering work through a Comment.io worklog. Talk to it about dev work in plain language and it picks the right path: shape a rough idea (`comment-spec`), build a defined feature (`comment-feature`), fix a defect (`comment-bug`), or try a fast change you'll validate later (`comment-prototype`). Invoke as `$comment-dev` / `/comment-dev`, or when someone describes coding work — "build / add / implement", "fix / it's broken", "let me try / quick tweak / show me", "should we / scope this" — without naming a specific path. When the user already named a specific skill, let that one fire directly. Works identically under Codex and Claude Code.

Run a multi-agent code review on a pull request and post the result. Only invoke when explicitly requested as `$code-review` or `/code-review`.

Turn a user's report of something going wrong into a well-formed GitHub issue in the repo Claude is running in. Invoke explicitly as `$file-bug` or `/file-bug`, or when the user describes a defect, regression, broken behavior, confusing UX, error message, or a product idea and wants it captured as an issue/ticket — phrases like "file a bug", "open an issue for this", "log a ticket", "something's broken, write it up", or "track this idea". This skill investigates and writes the issue so the next person can understand AND reproduce the problem; it does NOT fix the bug or propose a fix.