Supercharging Your Workflow with Claude Code: Commands, Hooks, Subagents & Beyond

🎙️ Podcast Insights

This article is inspired by Arvid Kahl and James Phoenix’s conversation on Claude Code.
👉 Listen to the full episode here: Spotify Link.

They discussed how Claude can move beyond being “just a prompt assistant” into acting as a junior engineer that plans, executes, and self-checks work—a theme you’ll see woven throughout the sections below.

In a recent podcast episode, the hosts dove deep into how Claude Code is changing the way developers orchestrate their projects. It wasn’t just about prompts—it was about building self-regulating workflows that layer Claude into your repo, your CI, and even your nightly jobs.

Here’s a breakdown that combines those podcast insights with examples from Claude’s official docs.

---

1. Claude Commands: One-Offs and Scheduled Work

Commands don’t always have to be ad-hoc. You can treat Claude like a cron job. Run it once a week, every night, or even on every push.

• Weekly one-off: Ask Claude to refresh your docs.md with the latest code updates.

• Hourly role enforcement: Have Claude check that your AI agents are still “assuming” their roles, overriding system prompts if needed.

• Nightly routines: Pick up a Linear ticket at 2 AM, plan implementation, run tests, verify results, and tee things up for the morning.

Example GitHub Action:

on:
  schedule:
    - cron: "0 0 * * *"  # every night
jobs:
  nightly-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Update Docs
        uses: ./.github/actions/claude-pr-action
        with:
          trigger_phrase: "update docs"
          timeout_minutes: "30"

(Docs reference)

---

2. Claude Code Hooks: Building Self-Correcting Loops

One highlight from the podcast: don’t just tell Claude to do something—make it self-check along the way.

• Run type checks.

• List errors.

• Encourage self-evaluation between steps.

• Force it into loops where it must fix errors before moving forward.

Hook Example (auto-format TypeScript after edits):

"PostToolUse": [{
  "matcher": "Edit|Write",
  "hooks": [{
    "type": "command",
    "command": "jq -r '.tool_input.file_path' | { read f; if echo \"$f\" | grep -q '\\.ts$'; then npx prettier --write \"$f\"; fi; }"
  }]
}]

This ensures Claude doesn’t just “think” the code looks right—it is right.
(Docs reference)

---

3. Rules with Claude.md

Another key insight: codify rules so Claude has a playbook.

• Put broad rules in the root Claude.md.

• Keep localized rules in the folder they belong to (like frontend/Claude.md).

---

4. Smarter Testing Strategies

Instead of running all tests every time:

• Only run tests relevant to the changed files.

• Use layers:

  • Unit tests for small functions.

  • Integration tests for multiple modules.

  • Playwright tests for the front end (slower, but realistic).

Claude can orchestrate this testing hierarchy, picking the right scope based on what’s changed.

---

5. Git Work Trees & Parallelization

The podcast covered using Git work trees and Supabase factory functions to parallelize testing.

• Run tests in parallel across work trees.

• Let Claude coordinate those runs automatically.

This is where automation starts looking like an in-house CI/CD engineer.

---

6. Supervisor & Subagents

A powerful pattern: treat Claude as a supervisor layer with subagents underneath.

• Supervisor: Orchestrates. Asks “have you really finished?” before marking a task done.

• Subagents: Each has a role (e.g., Python dev, frontend engineer, tester). Keep their Claude.md configs under 150 lines for clarity.

Example Subagent (Python Developer):

---
name: python-dev
description: Write and debug Python code
tools: Read, Write, Bash, PipInstall
---
Act as a Python developer. Write clean, tested, maintainable code.

(Docs reference)

Then in root Claude.md, define the order:

subagents:
  - python-dev
  - tester
  - code-reviewer

---

7. Vibe, CLI & Knowledge Management

Beyond code, Claude can manage the “vibe” of your project:

• Markdown → Claude constraints (enforce style guides, tone).

• CLI commands for instant prompts (/optimize, /fix-tests).

• Nightly ticket pickups: Claude can auto-assign itself a ticket, work overnight, and hand off results.

(Slash Commands reference)

---

8. Putting It All Together

Here’s what a Claude-powered dev loop can look like:

1. Nightly Claude Command runs: plan, code, test, verify.

2. Hooks enforce rules and auto-fixes.

3. Subagents take specialized roles.

4. Supervisor layer orchestrates.

5. Tests only run where needed, parallelized.

6. Rules in Claude.md keep behavior consistent.

7. CLI + Slash Commands make on-demand interactions fast.

---

Final Thoughts

The big takeaway from the podcast: Claude isn’t just a co-pilot. With commands, hooks, rules, and subagents, it can become a self-managing junior engineer that runs on a schedule, double-checks its own work, and collaborates with your team.

Think of it as moving from “AI that answers” → “AI that executes.”