Menu
Execute work efficiently while maintaining quality and finishing features
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Generate and critically evaluate grounded improvement ideas for the current project. Use when asking what to improve, requesting idea generation, exploring surprising improvements, or wanting the AI to proactively suggest strong project directions before brainstorming one in depth. Triggers on phrases like 'what should I improve', 'give me ideas', 'ideate on this project', 'surprise me with improvements', 'what would you change', or any request for AI-generated project improvement suggestions rather than refining the user's own idea.
Create structured plans for any multi-step task -- software features, research workflows, events, study plans, or any goal that benefits from structured breakdown. Also deepen existing plans with interactive review of sub-agent findings. Use for plan creation when the user says 'plan this', 'create a plan', 'write a tech plan', 'plan the implementation', 'how should we build', 'what's the approach for', 'break this down', 'plan a trip', 'create a study plan', or when a brainstorm/requirements document is ready for planning. Use for plan deepening when the user says 'deepen the plan', 'deepen my plan', 'deepening pass', or uses 'deepen' in reference to a plan.
[BETA] Execute work with external delegate support. Same as gh:work but includes experimental Codex delegation mode for token-conserving code implementation.
Refresh stale or drifting learnings and pattern docs in docs/solutions/ by reviewing, updating, consolidating, replacing, or deleting them against the current codebase. Use after refactors, migrations, dependency upgrades, or when a retrieved learning feels outdated or wrong. Also use when reviewing docs/solutions/ for accuracy, when a recently solved problem contradicts an existing learning, when pattern docs no longer reflect current code, or when multiple docs seem to cover the same topic and might benefit from consolidation.
Document a recently solved problem to compound your team's knowledge or update CONCEPTS.md, the project's shared domain vocabulary.
Start the dev server, open the feature in a browser, and iterate on improvements together. Manual invocation only — type /gh:polish to run it.
| name | gh:work |
| description | Execute work efficiently while maintaining quality and finishing features |
| argument-hint | [Plan doc path or description of work. Blank to auto use latest plan doc] |
Execute work efficiently while maintaining quality and finishing features.
This command takes a work document (plan or specification) or a bare prompt describing the work, and executes it systematically. The focus is on shipping complete features by understanding requirements quickly, following existing patterns, and maintaining quality throughout.
Engineering discipline overlay: For non-trivial engineering work, bias toward vertical red-green-refactor: choose one observable behavior, create or identify a failing check for that behavior, make the smallest implementation change to pass it, then refactor. Avoid horizontal slices that separately "finish schema/API/UI" without an end-to-end proof. See ../agent-native-architecture/references/engineering-discipline-from-mattpocock-skills.md.
<input_document> #$ARGUMENTS </input_document>
Determine how to proceed based on what was provided in <input_document>.
Plan document (input is a file path to an existing plan or specification): read the plan's metadata first -- YAML frontmatter for a markdown plan, or visible header text for an HTML plan. If it carries execution: knowledge-work, this is a non-code plan -- read references/non-code-execution.md and follow that carve-out instead of the normal code lifecycle. Otherwise, skip to Phase 1.
Bare prompt (input is a description of work, not a file path):
Scan the work area
Assess complexity and route
| Complexity | Signals | Action |
|---|---|---|
| Trivial | 1-2 files, no behavioral change (typo, config, rename) | Proceed to Phase 1 step 2 (environment setup), then implement directly — no task list, no execution loop. Apply Test Discovery if the change touches behavior-bearing code |
| Small / Medium | Clear scope, under ~10 files | Build a task list from discovery. Proceed to Phase 1 step 2 |
| Large | Cross-cutting, architectural decisions, 10+ files, touches auth/payments/migrations | Inform the user this would benefit from /gh:brainstorm or /gh:plan to surface edge cases and scope boundaries. Honor their choice. If proceeding, build a task list and continue to Phase 1 step 2 |
For any non-trivial bare prompt, form a lightweight execution contract before implementation: current assumptions, the minimal change that should satisfy the request, explicit non-goals, and verification criteria. Keep this compact; trivial typo/config fixes do not need ceremony.
Before Phase 1, log the skill start event so this execution appears on the task board:
gale-task log skill_started --skill gh:work --title "${ARGUMENTS:-work}" 2>/dev/null || true
If gale-task is not on PATH, skip silently — this must never block the skill.
Before Phase 1, query the vector memory database for related execution context:
Extract a search query from the work document or bare prompt:
Run (requires env vars HKT_MEMORY_API_KEY, HKT_MEMORY_BASE_URL, HKT_MEMORY_MODEL):
memory_root="$(gale-memory resolve-root 2>/dev/null || true)"
[ -n "$memory_root" ] && export HKT_MEMORY_DIR="$memory_root"
hkt-memory retrieve \
--query "<extracted query>" \
--layer all --limit 10 --min-similarity 0.35 \
--vector-weight 0.7 --bm25-weight 0.3
If results returned, prepare context for Phase 1 execution:
## Related context from HKTMemory
Source: vector database. Treat as additional context, not primary evidence.
[results here, each tagged with (similarity: X.XX)]
Use this to:
If no results or command error, proceed silently.
In addition to vector retrieval, query related historical work session records:
Build a search query from the current task title and skill name
Run (requires env vars HKT_MEMORY_API_KEY, HKT_MEMORY_BASE_URL, HKT_MEMORY_MODEL):
memory_root="$(gale-memory resolve-root 2>/dev/null || true)"
[ -n "$memory_root" ] && export HKT_MEMORY_DIR="$memory_root"
hkt-memory session-search \
--query "<skill name: gh:work — task title or feature description>" \
--limit 5
If results returned, prepare a context block for later phases:
## Related Historical Work Sessions
Source: session record search. Supplementary context only, not primary evidence.
[results list]
If no results or command error, proceed silently without blocking Phase 1.
Read Plan and Clarify (skip if arriving from Phase 0 with a bare prompt)
Implementation Units, Work Breakdown, Requirements (or legacy Requirements Trace), Files, Test Scenarios, or Verification, use those as the primary source material for executionExecution note on each implementation unit — these carry the plan's execution posture signal for that unit (for example, test-first or characterization-first). Note them when creating tasks.Deferred to Implementation or Implementation-Time Unknowns section — these are questions the planner intentionally left for you to resolve during execution. Note them before starting so they inform your approach rather than surprising you mid-taskScope Boundaries section — these are explicit non-goals. Refer back to them if implementation starts pulling you toward adjacent workExecution notestatus: frontmatter or - [ ] / - [x] marks on unit headings — ignore them as state; per-unit completion is determined during execution by reading the current file state.Setup Environment
First, check the current branch:
current_branch=$(git branch --show-current)
default_branch=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')
# Fallback if remote HEAD isn't set
if [ -z "$default_branch" ]; then
default_branch=$(git rev-parse --verify origin/main >/dev/null 2>&1 && echo "main" || echo "master")
fi
If already on a feature branch (not the default branch):
First, check whether the branch name is meaningful — a name like feat/crowd-sniff or fix/email-validation tells future readers what the work is about. Auto-generated worktree names (e.g., worktree-jolly-beaming-raven) or other opaque names do not.
If the branch name is meaningless or auto-generated, suggest renaming it before continuing:
git branch -m <meaningful-name>
Derive the new name from the plan title or work description (e.g., feat/crowd-sniff). Present the rename as a recommended option alongside continuing as-is.
Then ask: "Continue working on [current_branch], or create a new branch?"
If on the default branch, choose how to proceed:
Option A: Create a new branch
git pull origin [default_branch]
git checkout -b feature-branch-name
Use a meaningful name based on the work (e.g., feat/user-authentication, fix/email-validation).
Option B: Use a worktree (recommended for parallel development)
skill: git-worktree
# The skill will create a new branch from the default branch in an isolated worktree
Option C: Continue on the default branch
Recommendation: Use worktree if:
Create Task List (skip if Phase 0 already built one, or if Phase 0 routed as Trivial)
TaskCreate/TaskUpdate/TaskList in Claude Code, update_plan in Codex, or the equivalent on other harnesses) to break the plan into actionable tasksExecution note into the task when presentPatterns to follow field before implementing — these point to specific files or conventions to mirrorVerification field as the primary "done" signal for that taskChoose Execution Strategy
After creating the task list, decide how to execute based on the plan's size and dependency structure:
| Strategy | When to use |
|---|---|
| Inline | 1-2 small tasks, or tasks needing user interaction mid-flight. Default for bare-prompt work — bare prompts rarely produce enough structured context to justify subagent dispatch |
| Serial subagents | 3+ tasks with dependencies between them. Each subagent gets a fresh context window focused on one unit — prevents context degradation across many tasks. Requires plan-unit metadata (Goal, Files, Approach, Test scenarios) |
| Parallel subagents | 3+ tasks that pass the Parallel Safety Check (below). Dispatch independent units simultaneously, run dependent units after their prerequisites complete. Requires plan-unit metadata |
Parallel Safety Check — required before choosing parallel dispatch:
Files: section (Create, Modify, and Test paths)config/routes.rb — using serial dispatch"). Serial subagents still provide context-window isolation without shared-directory write races.Even with no file overlap, parallel subagents sharing the orchestrator's working directory face git index contention (concurrent staging/committing corrupts the index) and test interference (concurrent test runs pick up each other's in-progress changes). Worktree isolation eliminates both; the shared-directory fallback constraints below mitigate them.
Subagent isolation — give each parallel subagent its own working tree:
Agent tool): pass isolation: "worktree" and run_in_background: true. The harness creates a per-subagent worktree under .claude/worktrees/agent-<id> on its own branch. Verify .claude/worktrees/ is gitignored before relying on this.spawn_agent, Pi subagent): subagents share the orchestrator's directory.Subagent dispatch uses your available subagent or task spawning mechanism. For each unit, give the subagent:
Shared-directory fallback constraints — apply only when worktree isolation is unavailable:
git add), create commits, or run the project test suite. The orchestrator handles testing, staging, and committing after all parallel units complete."Permission mode: Omit the mode parameter when dispatching subagents so the user's configured permission settings apply. Do not pass mode: "auto" — it overrides user-level settings like bypassPermissions.
After each subagent completes (serial mode):
Files: listAfter all parallel subagents in a batch complete (worktree-isolated mode):
git merge --abort) and re-dispatch the conflicting unit serially against the now-merged tree — hand-resolving silently picks a side and discards one unit's intent. (Predicted overlap from the Parallel Safety Check surfaces here as a conflict, not as silent data loss in shared-directory mode.)git worktree unlock <absolute-path>git worktree remove <absolute-path>git branch -d <branch-name> (the branch outlives the worktree by default and accumulates as orphans if not cleaned up; -d lowercase refuses to delete unmerged branches, which is the safety we want — if it fails, investigate before forcing)After all parallel subagents in a batch complete (shared-directory fallback):
Files: lists). Subagents may create or modify files not anticipated during planning — this is expected, since plans describe what not how. A collision only matters when 2+ subagents in the same batch modified the same file. In a shared working directory, only the last writer's version survives — the other unit's changes to that file are lost. If a collision is detected: commit all non-colliding files from all units first, then re-run the affected units serially for the shared file so each builds on the other's committed workTask Execution Loop
For each task in priority order:
while (tasks remain):
- Mark task as in-progress
- Read any referenced files from the plan or discovered during Phase 0
- **If the unit's work is already present and matches the plan's intent** (files exist with the expected capability, or the unit's `Verification` criteria are already satisfied by the current code), the work has likely shipped on a prior branch or session. Verify it matches, mark the task complete, and move on. Do not silently reimplement.
- Look for similar patterns in codebase
- Find existing test files for implementation files being changed (Test Discovery — see below)
- Implement following existing conventions
- Add, update, or remove tests to match implementation changes (see Test Discovery below)
- Run System-Wide Test Check (see below)
- Run tests after changes
- Assess testing coverage: did this task change behavior? If yes, were tests written or updated? If no tests were added, is the justification deliberate (e.g., pure config, no behavioral change)?
- Mark task as completed
- Evaluate for incremental commit (see below)
When a unit carries an Execution note, honor it. For test-first units, write the failing test before implementation for that unit. For characterization-first units, capture existing behavior before changing it. For units without an Execution note, proceed pragmatically.
Guardrails for execution posture:
Surgical-change guardrails:
Test Discovery — Before implementing changes to a file, find its existing test files (search for test/spec files that import, reference, or share naming patterns with the implementation file). When a plan specifies test scenarios or test files, start there, then check for additional test coverage the plan may not have enumerated. Changes to implementation files should be accompanied by corresponding test updates — new tests for new behavior, modified tests for changed behavior, removed or updated tests for deleted behavior.
Test Scenario Completeness — Before writing tests for a feature-bearing unit, check whether the plan's Test scenarios cover all categories that apply to this unit. If a category is missing or scenarios are vague (e.g., "validates correctly" without naming inputs and expected outcomes), supplement from the unit's own context before writing tests:
| Category | When it applies | How to derive if missing |
|---|---|---|
| Happy path | Always for feature-bearing units | Read the unit's Goal and Approach for core input/output pairs |
| Edge cases | When the unit has meaningful boundaries (inputs, state, concurrency) | Identify boundary values, empty/nil inputs, and concurrent access patterns |
| Error/failure paths | When the unit has failure modes (validation, external calls, permissions) | Enumerate invalid inputs the unit should reject, permission/auth denials it should enforce, and downstream failures it should handle |
| Integration | When the unit crosses layers (callbacks, middleware, multi-service) | Identify the cross-layer chain and write a scenario that exercises it without mocks |
System-Wide Test Check — Before marking a task done, pause and ask:
| Question | What to do |
|---|---|
| What fires when this runs? Callbacks, middleware, observers, event handlers — trace two levels out from your change. | Read the actual code (not docs) for callbacks on models you touch, middleware in the request chain, after_* hooks. |
| Do my tests exercise the real chain? If every dependency is mocked, the test proves your logic works in isolation — it says nothing about the interaction. | Write at least one integration test that uses real objects through the full callback/middleware chain. No mocks for the layers that interact. |
| Can failure leave orphaned state? If your code persists state (DB row, cache, file) before calling an external service, what happens when the service fails? Does retry create duplicates? | Trace the failure path with real objects. If state is created before the risky call, test that failure cleans up or that retry is idempotent. |
| What other interfaces expose this? Mixins, DSLs, alternative entry points (Agent vs Chat vs ChatMethods). | Grep for the method/behavior in related classes. If parity is needed, add it now — not as a follow-up. |
| Do error strategies align across layers? Retry middleware + application fallback + framework error handling — do they conflict or create double execution? | List the specific error classes at each layer. Verify your rescue list matches what the lower layer actually raises. |
When to skip: Leaf-node changes with no callbacks, no state persistence, no parallel interfaces. If the change is purely additive (new helper method, new view partial), the check takes 10 seconds and the answer is "nothing fires, skip."
When this matters most: Any change that touches models with callbacks, error handling with fallback/retry, or functionality exposed through multiple interfaces.
Incremental Commits
After completing each task, evaluate whether to create an incremental commit:
| Commit when... | Don't commit when... |
|---|---|
| Logical unit complete (model, service, component) | Small part of a larger unit |
| Tests pass + meaningful progress | Tests failing |
| About to switch contexts (backend → frontend) | Purely scaffolding with no behavior |
| About to attempt risky/uncertain changes | Would need a "WIP" commit message |
Heuristic: "Can I write a commit message that describes a complete, valuable change? If yes, commit. If the message would be 'WIP' or 'partial X', wait."
If the plan has Implementation Units, use them as a starting guide for commit boundaries — but adapt based on what you find during implementation. A unit might need multiple commits if it's larger than expected, or small related units might land together. Use each unit's Goal to inform the commit message.
Commit workflow:
# 1. Verify tests pass (use project's test command)
# Examples: bin/rails test, npm test, pytest, go test, etc.
# 2. Stage only files related to this logical unit (not `git add .`)
git add <files related to this logical unit>
# 3. Commit with conventional message
git commit -m "feat(scope): description of this unit"
Handling merge conflicts: If conflicts arise during rebasing or merging, resolve them immediately. Incremental commits make conflict resolution easier since each commit is small and focused.
Note: Incremental commits use clean conventional messages without attribution footers. The final Phase 4 commit/PR includes the full attribution.
Parallel subagent mode: Commit ownership is split by isolation mode (see Phase 1 Step 4):
Follow Existing Patterns
Test Continuously
Simplify as You Go
After completing a cluster of related implementation units (or every 2-3 units), review recently changed files for simplification opportunities — consolidate duplicated patterns, extract shared helpers, and improve code reuse and efficiency. This is especially valuable when using subagents, since each agent works with isolated context and can't see patterns emerging across units.
Don't simplify after every single unit — early patterns may look duplicated but diverge intentionally in later units. Wait for a natural phase boundary or when you notice accumulated complexity.
If a /simplify skill or equivalent is available, use it. Otherwise, review the changed files yourself for reuse and consolidation opportunities.
Figma Design Sync (if applicable)
For UI work with Figma designs:
Track Progress
When all Phase 2 tasks are complete and execution transitions to quality check, read references/shipping-workflow.md for the full shipping workflow: quality checks, code review, final validation, PR creation, and notification.
After the work is complete and the shipping workflow has finished (PR created or changes committed):
Summarize what was accomplished:
Run:
memory_root="$(gale-memory resolve-root 2>/dev/null || true)"
[ -n "$memory_root" ] && export HKT_MEMORY_DIR="$memory_root"
hkt-memory store \
--content "<execution summary with context>" \
--title "Work: [plan title or feature description]" \
--topic "work-execution" \
--layer all
Log on success: Stored execution record to HKTMemory
On error, proceed silently — execution storage is supplementary
Note: This creates a searchable record of completed work for future reference when similar tasks arise.
gh:work may optionally use GitNexus to enrich execution context when the local repo has a GitNexus index. GitNexus provides code-structure awareness, likely file/module hints, and impact analysis that can improve implementation quality. It is never required — missing gitnexus, a stale index, timeout, or command failure must not block execution.
Before using GitNexus, verify the repo is indexed:
# Check if gitnexus is available and the repo has an index
gitnexus list 2>/dev/null && echo "GitNexus available" || echo "GitNexus unavailable — proceeding without it"
For multi-repo environments, use explicit repo labels: gitnexus list -r <repo-label>.
When GitNexus is available, prefer these stable commands:
gitnexus cypher -r <repo-label> — Markdown/file/content lookup. Use for finding relevant files, symbols, or content patterns before implementing changes.gitnexus context -r <repo-label> — Symbol-level context. Use for understanding the surroundings of a specific function, class, or module being modified.gitnexus impact -r <repo-label> — Impact analysis. Use for assessing blast radius before changes that touch shared surfaces, callbacks, or exported APIs.gitnexus query — Best-effort/experimental only. Current versions can emit read-only FTS warnings or return empty markdown-heavy results. Use only when the stable commands above do not cover the need, and treat results as supplementary.gitnexus cypher for the key components identified in the prompt or plan. Use findings to refine the task list and identify files likely to change.gitnexus impact can surface callers or consumers that local grep might miss. Cross-check with actual source files — GitNexus findings are guidance only, never primary evidence.gitnexus context around the test entry points can help identify related test utilities or fixtures.gitnexus currently advertises PolyForm-Noncommercial-1.0.0; production/company usage needs commercial/legal review. P0 remains optional/local.
GitNexus is optional code intelligence for gh:work. It is not a mandatory runtime dependency, not a GitHub fact source, and not HKTMemory. Always re-check code and tests independently.
After the work workflow is fully complete, log the completion event:
gale-memory store-session-transcript --skill gh:work --phase completed --source-mode phase_completed --importance high --summary "<concise work summary>" --content "<final summary, changed files, verification, blockers, PR/issue context>" to make the completed work session available to list-recent and session-search.gale-memory is not on PATH or the command fails, skip and continue — this must never block the skill.gale-task log skill_completed to record the completion event.gale-task is not on PATH or the command fails, skip and continue — this must never block the skill.