playbooks

home / skills / phrazzld / claude-config / build

build skill

/skills/build

This skill helps you implement a GitHub issue with semantic commits by delegating to Codex, reviewing, and shipping tested code.

npx playbooks add skill phrazzld/claude-config --skill build

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.1 KB
---
name: build
description: |
  Implement GitHub issue with semantic commits.
  Codex writes first draft, you review and ship.
  Use when: building a feature, implementing an issue, shipping code.
  Composes: Codex delegation, quality gates, ousterhout review.
argument-hint: <issue-id>
effort: high
---

# /build

Stop planning. Start shipping.

## Role

Senior engineer. Codex is your software engineer.

## Objective

Implement Issue #`$ARGUMENTS`. Ship working, tested, committed code on a feature branch.

## Latitude

- Delegate ALL work to Codex by default (investigation AND implementation)
- Keep only trivial one-liners where delegation overhead > benefit
- If Codex goes off-rails, re-delegate with better direction

## Startup

```bash
gh issue view $1 --comments
gh issue edit $1 --remove-label "status/ready" --add-label "status/in-progress" --add-assignee phrazzld
```

If on `master`/`main`, branch: `feature/issue-$1` or `fix/issue-$1`.

## Execution Loop

For each logical chunk:

1. **Delegate** — Codex with clear spec + pattern reference + verify command
2. **Review** — `git diff --stat && pnpm typecheck && pnpm lint && pnpm test`
3. **Commit** — `feat: description (#$1)` if tests pass
4. **Repeat** until complete

Final commit: `feat: complete feature (closes #$1)`

## Multi-Module Mode (Agent Teams)

When the issue spans 3+ distinct modules (e.g., API + UI + tests):

1. Create team with one teammate per module
2. Shared task list tracks dependencies (API must land before UI integration)
3. Each teammate runs its own Codex delegation loop on its module
4. Lead coordinates commit sequencing

Use when: cross-layer features, 3+ modules, clear boundaries.
Don't use when: single module, sequential dependencies dominate.

## Post-Implementation

1. `code-simplifier:code-simplifier` agent for clarity
2. `ousterhout` agent for module depth review
3. Commit simplifications separately

## Issue Comments

Leave breadcrumbs: starting work, decision points, scope creep, completion. Concise, high-context, useful, human.

## Output

Commits made, files changed, verification status.

Overview

This skill guides a senior engineer workflow to implement a GitHub issue using semantic commits and automated delegation to Codex. It focuses on shipping working, tested code on a feature branch with clear iteration, review gates, and final delivery. The goal is rapid, repeatable delivery while preserving code quality and clear repository history.

How this skill works

You delegate detailed implementation tasks to Codex with a concise spec, reference patterns, and a verification command. After Codex produces a change, you run fast review gates (diff summary, typecheck, lint, tests), commit with a semantic message if green, and repeat until the issue is complete. For multi-module work, form a small team, split responsibilities by module, and coordinate commit sequencing. Finish with clarity passes and a final commit that closes the issue.

When to use it

  • Building a new feature tied to a tracked GitHub issue.
  • Implementing a bugfix or enhancement that should be shipped on a feature branch.
  • Shipping code that requires consistent semantic commits and automated review gates.
  • Coordinating cross-module changes spanning API, UI, and tests.
  • When you want to maximize delegation while keeping tight quality control.

Best practices

  • Delegate almost all implementation to Codex, but keep trivial one-liners locally when delegation adds overhead.
  • Provide clear specs: include expected behavior, edge cases, and a pattern reference for implementation.
  • Run verification commands after each chunk: git diff --stat; pnpm typecheck; pnpm lint; pnpm test.
  • Use consistent commit messages: feature commits as feat: description (#ISSUE) and final commit feat: complete feature (closes #ISSUE).
  • Leave concise, high-context issue comments tracking start, decisions, scope changes, and completion.

Example use cases

  • Implementing a new REST endpoint with tests and client updates on a feature branch.
  • Fixing a reproducible bug, delegating patch logic to Codex, and verifying via unit tests.
  • Coordinating API, frontend, and test changes across three modules with a small agent team.
  • Refactoring a module for clarity, then applying an automated code-simplifier pass and committing separately.
  • Shipping an enhancement that requires semantic commit history for changelog generation.

FAQ

How do I start work on a GitHub issue with this workflow?

Mark the issue in-progress, assign yourself, and create a feature branch named feature/issue-<number> or fix/issue-<number> if on main/master. Then delegate the first implementation chunk to Codex with a clear spec.

What verification steps should I run after Codex produces changes?

Run git diff --stat to inspect changes, then pnpm typecheck, pnpm lint, and pnpm test. Only commit if all gates pass.