Planning & Workflow

Search code across all your GitHub repos, including private ones, with ripgrep

Stage task-scoped commits, write commit messages and rebase instead of merging

Use the Plannotator tool for plan reviews, code reviews and annotated files

Open a visual annotation view of a file or URL and act on the notes

Annotate the latest assistant message in review and revise it from the notes

Turn an idea into a reviewed goal package and a codebase execution plan

Manage git worktrees with the wt CLI, including hooks and per-repo config

Create a new git worktree, optionally in another repo, and switch into it

Gate code changes through review, tests, lint and CI before pushing a pull request

Turn a PRD into a testable design doc with behavior, data and acceptance criteria

Build a feature from its design doc in an isolated developer, reviewer and tester loop

Write Conventional Commit messages for your repository changes

Explore intent and options before any creative work, from features to a business idea

Set up Chinese commit messages, commitlint and changelog for Conventional Commits

Configure SSH, HTTPS and CI access for Gitee, Coding.net, JiHu GitLab and CNB

Carry out a written implementation plan step by step in the current session

Decide how to merge, keep or discard a finished branch after tests pass

Create an isolated git worktree for a feature before implementation starts

Turn a spec or requirements into a step-by-step plan before writing any code

Turn requirements analysis into a system design with architecture and interface specs

Query GitCode repos, issues, pull requests and files with the gitcode-api CLI

Run a lightweight build, handoff and close cycle for a mission or slice

Verify a change actually works before claiming it is complete or committing

Route GitHub URLs, PRs and issues through the authenticated gh CLI, not curl

Triage open issues and PRs with gh, merge ready bot PRs and close resolved issues

Check delegated file edits in the workspace before accepting that they succeeded

Check directories, read files in parallel and validate TypeScript imports in one pass

Archive codebase deliverables into a ZIP file before marking the task complete

Skip file writes when the content already matches to avoid needless changes

Check folder layout, read files in parallel batches and validate TypeScript imports

Package codebase deliverables as a ZIP in a dedicated final step

Export codebase deliverables as ZIP archives in a separate finalization step

Break a plan into independent vertical slices and roadmap entries or issues

Compare three or more radically different designs for a module or API

Stress-test a plan through a relentless interview until every decision is resolved

Require fresh verification evidence before claiming a task, commit or PR is done

Execute structured plan files step by step and track each task status

Generate pull request descriptions from git diffs and commits with GitHub CLI

Choose the right Zoom SDK or API approach before you start building

Plan a Zoom integration with the right products, APIs and SDKs before coding

Choose which Zoom product fits your use case before starting development

Get an open pull request mergeable by clearing review threads and failing checks

Manage GitHub API quota and local archive caches to avoid rate limits

Turn a rough idea into an approved, decision-complete plan before any coding

Navigate unknown codebases and keep a growing notebook of what it learns

Map business domains and bounded contexts in a codebase with DDD strategic design

Group existing components into business domains to plan service boundaries

Address review comments on the open GitHub PR for the current branch using gh

Scaffold Nx projects, libraries and components with workspace generators