Stop manually checking UI changes and writing PRs. Use Claude Code's preview feature and custom skills to automate verification and delegation.

How to Delegate UI Verification and PR Creation to Claude Code

The Technique — From Implementer to Manager

The author's key insight was a role shift: they stopped being the implementer and became a manager of AI agents. The biggest time sinks were manual PR creation (/git-pr) and UI verification. Both are perfect for delegation.

Why It Works — Removing Mental Overhead

Manual PR creation requires a context switch from coding to describing code. Each PR was a small interruption. The custom /git-pr skill reads the full diff and writes thorough descriptions automatically. The real win isn't just time saved—it's the uninterrupted flow.

For UI changes, manually previewing and eyeballing results made the developer a bottleneck. Claude Code's preview feature lets the agent set up a preview, persist session data, and verify the UI itself. This enables longer, unsupervised agent runs because they can catch their own mistakes.

How To Apply It — Two Concrete Workflows

1. Automate PR Creation with a Custom Skill

Create a claude_skills/git_pr.py file:

from claude_code.skills import skill

@skill("git-pr")
def create_pr():
    """
    Automatically stages changes, writes commit message, crafts PR description,
    pushes, and creates PR on GitHub. Reads full diff for thorough summaries.
    """
    # Your implementation here
    # Use git commands via subprocess
    # Generate PR description from diff
    # Push and create via GitHub API
    pass

Then just type /git-pr in Claude Code instead of manually staging, committing, and describing.

2. Delegate UI Verification

In your CLAUDE.md or when starting a UI task, add:

## UI Verification Workflow
1. Make the requested UI changes
2. Use Claude Code's preview feature to set up a live preview
3. Verify the UI matches requirements visually
4. Only notify me for final review after self-verification

This changes your definition of "done"—a change isn't complete until the agent has verified the UI themselves. You only step in for final review.

The Infrastructure Enabler — Sub-Second Restarts

The author mentions switching their server build to SWC, dropping restarts to under a second. This isn't just an optimization—it enables the delegation workflow. When agents can verify UI changes instantly, there's no waiting period where attention drifts.

Check your own build times. If server restarts take more than a few seconds, consider:

• Switching to SWC or esbuild
• Using hot module replacement
• Running development builds in memory

Fast rebuilds mean you never leave the flow, making agent delegation practical.

The Result — Parallel Work Without Bottlenecks

With automated PRs and delegated verification, the author could work on multiple things simultaneously. They weren't blocked reviewing their own agent's work because the agent handled verification. They could review PRs from other agents and teammates while their own agents continued working.

This is the real productivity multiplier: not just doing one thing faster, but doing multiple things in parallel because you're no longer the bottleneck.

Originally published on gentic.news