Master Warp Terminal with Claude Code

Introduction

30 Second Summary

Most developers spend hours switching between terminal tabs, copy-pasting output into AI assistants, and manually repeating workspace setups every morning. What if your terminal could handle all of that automatically?

In this project, you will configure Warp Terminal as a power-user workspace and build a CLI tool by steering Claude Code through Warp's agentic features like prompt queueing, Rich Input, and interactive code review.

What You'll Build

A fully configured Warp power-user workspace and a small CLI tool called devpulse built end-to-end using Warp's agentic features.

By the end of this project, you'll have:

• A customized settings.toml with power-user vertical tabs, prompt queueing defaults, and Rich Input configuration.
• A reusable Tab Config that launches a parameterized multi-pane Claude Code workspace in one click.
• A working devpulse bash script built entirely by steering Claude Code through Warp's power-user features.
• Secret Mission: Use /orchestrate to break a feature enhancement into parallel subtasks across multiple agent sessions.

Are there any prerequisites?

This project assumes you already have Warp Terminal installed with vertical tabs enabled and Claude Code installed with an active subscription. You should also be comfortable with terminal basics and Git.

Configure settings.toml for Power-User Defaults

Warp stores every preference in a single TOML file called settings.toml. Instead of clicking through menus one at a time, you can edit this file directly to batch-configure your entire setup.

In this step, you will configure vertical tabs, prompt queueing, and Rich Input behavior all at once. Changes hot-reload the moment you save, so you see results instantly.

In this step, get ready to:

• Open your settings.toml file from Warp's Settings panel.
• Configure vertical tabs to show branch info, PR links, and diff stats in expanded mode.
• Set agent defaults for prompt queueing and Rich Input auto-behavior.

Open your settings file

Warp's settings.toml holds every configurable preference in one place. Opening it directly lets you batch-edit settings instead of hunting through GUI menus.

• In Warp, open Settings by pressing CMD-,.
• Scroll to the bottom of the Settings panel.
• Click Open settings file.

Warp opens settings.toml in its built-in editor. Take a moment to scan the current contents. Any sections you already have configured will stay intact.

What is settings.toml?

This is a plain-text configuration file that Warp reads on startup and hot-reloads whenever you save. You only need to include settings you want to change. Warp uses built-in defaults for everything else.

Add power-user vertical tabs configuration

Vertical tabs give you a sidebar showing every open session at a glance. In expanded mode, each row displays the active branch, PR link, and diff stats so you can track multiple Claude Code sessions without switching tabs.

• In settings.toml, add the following [appearance.vertical_tabs] section (or update it if it already exists):

[appearance.vertical_tabs]
view_mode = "expanded"
primary_info = "branch"
show_diff_stats = true
show_pr_link = true
display_granularity = "panes"

What does this configuration do?

• view_mode = "expanded" switches from the default compact sidebar to a wider panel showing full metadata per row.
• primary_info = "branch" displays the current git branch as the main label on each tab row.
• show_diff_stats = true adds lines-added/removed counts so you can spot large changes at a glance.
• show_pr_link = true surfaces a clickable PR link when the branch has an open pull request.
• display_granularity = "panes" gives each pane its own row, so every Claude Code session shows separately.

• Save settings.toml.
• Look at your vertical tabs panel on the left. It should now display in expanded mode with branch names visible on each row.

Vertical tabs not showing in expanded mode?

• Confirm you have vertical tabs enabled. Go to Settings then Appearance then Tabs and check that Use vertical tab layout is toggled on.
• Make sure you used the exact section header [appearance.vertical_tabs] with no typos. TOML is case-sensitive.
• Check for duplicate section headers. If [appearance.vertical_tabs] appears twice, Warp only reads the last one.

Why aren't my vertical tabs showing expanded mode after saving settings.toml?

Configure agent defaults for prompt queueing and Rich Input

By default, submitting a prompt while an agent is responding interrupts it. Switching to queue mode means your follow-up prompts line up and send automatically after each response finishes.

Rich Input is the multi-line editor you open with Ctrl-G during a Claude Code session. Configuring it to auto-open and auto-dismiss keeps your flow uninterrupted.

• Below your vertical tabs section in settings.toml, add the agent and Rich Input configuration:

[agent]
prompt_submission_mode = "queue"

[rich_input]
auto_open = true
auto_dismiss = true

What does this configuration do?

• prompt_submission_mode = "queue" makes new conversations default to queueing instead of interrupting. You can still toggle per-conversation with CMD+Shift+J.
• auto_open = true opens the Rich Input editor automatically when Claude Code enters a waiting state that needs your input.
• auto_dismiss = true closes the Rich Input editor after you submit your prompt, returning focus to the conversation.

• Save settings.toml. Warp hot-reloads immediately.
• To verify prompt queueing, start a new agent conversation by pressing CMD+Enter and send a prompt.
• While the agent is responding, type a second prompt and press Enter. The prompt should appear in the queued prompts panel above the input instead of interrupting the response.

Prompt not queueing?

• Make sure you saved the file after adding the [agent] section.
• Check that prompt_submission_mode is spelled exactly as shown, with no trailing spaces.
• Verify the value is "queue" (in quotes). Unquoted values in TOML are interpreted as booleans or numbers.

Why is my prompt interrupting the agent instead of queueing?

✔️ Awesome, I've got everything!

Great. Double check you have saved your file.

ⓧ I'd like to double check the full code

Here is the complete settings.toml configuration you should have at this point:

[appearance.vertical_tabs]
view_mode = "expanded"
primary_info = "branch"
show_diff_stats = true
show_pr_link = true
display_granularity = "panes"

[agent]
prompt_submission_mode = "queue"

[rich_input]
auto_open = true
auto_dismiss = true

Your settings are locked in and version-control ready. Next up, you will build a reusable Tab Config that launches a multi-pane Claude Code workspace in one click.

Build a Reusable Tab Config

Your settings.toml is configured and hot-reloaded. Vertical tabs show branch metadata, prompt queueing is on by default, and Rich Input auto-opens when agents need input.

Now you need a way to launch a full multi-pane workspace in a single click. Tab Configs are TOML files that define reusable tab layouts with pane splits, startup commands, and parameterized inputs. You will create one that opens a Claude Code agent pane alongside a terminal pane, pointed at any project directory you choose at launch time.

In this step, get ready to:

• Create a Tab Config file with a name, color, and parameterized project directory.
• Define a horizontal split layout with an agent pane and a terminal pane.
• Test the Tab Config by launching it from the + menu and verifying both panes.

Create the Tab Config file

Tab Configs live in ~/.warp/tab_configs/ on macOS. Each .toml file in that directory appears automatically in the + menu for one-click launching.

• Click the + button in the tab bar to open the new-tab menu.
• Click + New tab config.
• Warp creates a new .toml file in ~/.warp/tab_configs/ and opens it for editing.
• Rename the file to devpulse_workspace.toml.
• Replace the file contents with the following configuration to define your workspace identity and parameter:

name = "DevPulse Workspace"
color = "blue"

[params.project_dir]
default = "~/projects"

What does this configuration do?

• name sets the display name you see in the + menu when selecting this workspace.
• color assigns a tab color for quick visual identification in the vertical tabs panel.
• [params.project_dir] declares a parameter that Warp prompts you to fill in each time you launch this config. The default value pre-fills the prompt so you can accept it or override it with any directory.

• Save the file.

You will not see a visible change yet. The next chunk adds the pane layout that makes this config functional.

Define the pane layout

A Tab Config needs a layout section to define how panes are arranged. You will create a horizontal split with two panes: an agent pane for Claude Code on the left, and a terminal pane on the right that lands in your parameterized project directory.

• In devpulse_workspace.toml, add the following layout configuration below the [params.project_dir] section:

[[layout.split]]
direction = "horizontal"

[[layout.split.panes]]
id = "claude"
type = "agent"
focus = true

[[layout.split.panes]]
id = "terminal"
type = "terminal"
dir = "{{ params.project_dir }}"
startup_command = "echo \"Directory: $(pwd)\" && git branch --show-current 2>/dev/null && echo ''"

What does this layout do?

• [[layout.split]] with direction = "horizontal" arranges children left-to-right (side by side).
• The first pane (id = "claude") uses type = "agent" so it opens directly in Agent Mode, ready for Claude Code prompts.
• focus = true gives the agent pane keyboard focus on launch so you can start typing immediately.
• The second pane uses {{ params.project_dir }} in the dir field to reference the parameter you declared above. Warp substitutes whatever directory you choose at launch time.
• startup_command runs automatically when the terminal pane opens, printing the current directory and Git branch so you have immediate project context.

• Save devpulse_workspace.toml.
• Open the + menu in the tab bar. You should see DevPulse Workspace listed as an option.

Don't see DevPulse Workspace in the + menu?

• Confirm the file is saved at ~/.warp/tab_configs/devpulse_workspace.toml (not in a subfolder or a different directory).
• Check that the file has a .toml extension, not .toml.txt or similar.
• Verify the name field is present. Without it, Warp cannot display the config in the menu.

Ask for help: Why isn't my Tab Config showing up in the + menu?

✔️ Awesome, I've got everything!

Great. Double check you have saved your file before moving on.

ⓧ I'd like to double check the full code

Here is the complete devpulse_workspace.toml file:

name = "DevPulse Workspace"
color = "blue"

[params.project_dir]
default = "~/projects"

[[layout.split]]
direction = "horizontal"

[[layout.split.panes]]
id = "claude"
type = "agent"
focus = true

[[layout.split.panes]]
id = "terminal"
type = "terminal"
dir = "{{ params.project_dir }}"
startup_command = "echo \"Directory: $(pwd)\" && git branch --show-current 2>/dev/null && echo ''"

Test the Tab Config

Your Tab Config is saved and visible in the menu. Time to launch it and verify both panes work correctly.

• Click the + button in the tab bar.
• Click DevPulse Workspace in the menu.
• Warp prompts you for the project directory parameter. Accept the default (~/projects) or enter any directory that contains a Git repository.
• Press Enter to launch.

You should see a tab open with two panes side by side. The left pane is in Agent Mode (ready for Claude Code prompts). The right pane shows a terminal in your chosen directory with the current directory path and Git branch printed.

• Right-click the new tab in the vertical tabs panel.
• Confirm that the metadata (branch name, directory) displays correctly alongside the tab entry.

Why check the vertical tabs panel?

Your vertical tabs configuration from Step 1 set display_granularity to "panes". This means each pane gets its own row in the vertical tabs panel, showing branch and directory info per-pane. Confirming the metadata verifies your Step 1 settings are working together with your new Tab Config.

Seeing only one pane or an error?

• If you see a single pane instead of two, check that [[layout.split]] and both [[layout.split.panes]] entries are present. A missing section results in a single default pane.
• If the terminal pane shows your home directory instead of the parameter value, verify the dir field uses the exact template syntax {{ params.project_dir }} with spaces inside the braces.
• If the startup command does not run, confirm the startup_command field is on the terminal pane (the second [[layout.split.panes]] entry), not the agent pane.

Ask for help: My Tab Config launches but the pane layout is wrong. Help me debug.

Your one-click workspace launcher is ready. Next up, you will use this workspace to build a CLI tool by steering Claude Code with Rich Input, prompt queueing, and blocks as context.

Steer Claude Code with Rich Input and Prompt Queueing

Your workspace is configured and your Tab Config is ready to launch. Now it is time to actually build something with it.

In this step, you will use your new workspace to build a CLI tool called devpulse by mastering three Warp power-user features: Rich Input for complex multi-line prompts, prompt queueing to chain tasks without waiting, and blocks as context for zero-copy debugging.

In this step, get ready to:

• Launch your Tab Config and craft a multi-line prompt with Rich Input.
• Queue follow-up prompts while Claude Code works.
• Use blocks as context to debug errors without copy-pasting.

Launch your Tab Config and start Claude Code

Rich Input gives you an IDE-style editor for writing prompts. Instead of cramming everything into a single line, you can compose multi-line instructions with proper formatting and attach file context using @ mentions.

• Click the + button in the tab bar.
• Select DevPulse Workspace from the menu.
• Warp prompts you for a project directory. Enter the path to a new folder where you want to build the devpulse tool (for example, ~/Desktop/devpulse).
• The tab opens with two panes side by side: the agent pane on the left (focused) and the terminal pane on the right showing your project directory.

What is Rich Input?

Rich Input is Warp's IDE-style prompt editor. It gives you mouse support, multi-line editing, and @ mentions for referencing files and folders as context. Press Ctrl-G to open it while a supported agent is running.

Because you configured Rich Input to auto-open in your settings.toml, it may already be visible when you enter the agent pane. If not, press Ctrl-G to bring it up.

• In the agent pane, initialize a git repository so @ mentions work. Switch to terminal mode by pressing Cmd+I and run this command:

git init

• Switch back to Agent Mode by pressing Cmd+I again.
• Open Rich Input by pressing Ctrl-G.
• Write the following multi-line prompt in the Rich Input editor:

Create a bash script called `devpulse` that shows project health for any git repository.

The script should display:
- Current branch name
- Last commit message and relative time (e.g., "2 hours ago")
- Count of uncommitted changes
- Count of files containing TODO or FIXME comments (excluding node_modules, .git, vendor, venv, __pycache__, dist, and build directories)

Requirements:
- Use set -euo pipefail for safety
- Accept an optional directory argument (default to current directory)
- Verify the target is a git repository before running
- Exit with an error message if not a git repo

• Before submitting, type @. in the prompt to attach the current project directory as context.
• Submit the prompt. Rich Input auto-dismisses after submission (thanks to your settings.toml configuration) and Claude Code begins working.

Why use @ mentions?

Typing @ in Rich Input opens a context menu that searches your Git repository. You can reference files, folders, and code symbols directly in your prompt. This gives the agent precise context without copy-pasting paths or file contents.

Queue follow-up prompts while Claude Code works

Prompt queueing lets you line up your next instructions while the agent is still responding. Warp sends them automatically in order as each response finishes.

This means you can plan multiple steps ahead without waiting between each one.

• While Claude Code is still building the script, activate auto-queue by pressing Cmd+Shift+J.
• Type your first follow-up prompt and press Enter to queue it:

Make the script executable and add a usage message when called with --help or -h. The help should show the script name, a description, and the optional directory argument.

• Type your second follow-up prompt and press Enter to queue it:

Add color output using ANSI escape codes for the status indicators. Use green for clean/positive states, yellow for warnings (uncommitted changes, TODOs), red for errors, blue for informational items like the project name, and bold for labels.

• Look at the queued prompts panel between the response indicator and the input area. It shows your prompts in order from top (next to send) to bottom (last to send).
• Watch as Warp sends each prompt automatically after the previous response finishes.

How does the queued prompts panel work?

The panel appears whenever at least one prompt is queued. You can hover over any row to reorder prompts by dragging, edit them inline, or delete them.

If Claude Code encounters an error or you stop a response with Ctrl+C, the queue pauses automatically. Your queued prompts stay intact so you can review what should happen next.

Use blocks as context to iterate

Blocks as context is how you feed terminal output directly to the agent without copy-pasting. Every command you run in Warp produces a block of output. You can attach any block to your next prompt with a single shortcut.

• Once Claude Code finishes processing all queued prompts, switch to the terminal pane on the right.
• Run the script to test it:

./devpulse

• If the script runs and produces colored output showing your branch, last commit, change count, and TODO count, you are done with this substep.
• If you see errors or unexpected output, switch back to the agent pane.
• Press Cmd-Up to attach the terminal output block (containing the error) as context to your next prompt.
• Type a short fix request like "fix this error" and submit. Claude Code reads the exact error output and addresses it.
• Switch back to the terminal pane and run ./devpulse again to verify the fix.
• Repeat this cycle (run, attach block, ask for fix) until the script works correctly.

What does Cmd-Up do?

Pressing Cmd-Up attaches the previous terminal block as context to your next agent prompt. While holding Cmd, you can press Up or Down to select additional blocks. This feeds the exact error output to Claude Code without any manual copying.

Script not running?

If you see a "permission denied" error, the script may not be executable yet. Run chmod +x devpulse in the terminal pane and try again.

If you see "not a git repository," make sure you ran git init in your project directory earlier.

Help me debug my devpulse script.

Once the script runs and shows colored output with branch info, last commit details, uncommitted change count, and TODO file count, you have successfully steered Claude Code through three power-user features.

✔️ Awesome, I've got everything!

Great. Make sure devpulse runs without errors and displays colored output before moving on.

ⓧ I'd like to double check the full code

Your devpulse script should look similar to this. Claude Code may have produced slightly different formatting, but the key sections should all be present:

#!/usr/bin/env bash
set -euo pipefail

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
BOLD='\033[1m'
RESET='\033[0m'

# Help message
if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
    echo "Usage: devpulse [directory]"
    echo ""
    echo "Show project health: branch, last commit, uncommitted changes, and TODOs."
    echo ""
    echo "Arguments:"
    echo "  directory    Project directory to check (default: current directory)"
    exit 0
fi

# Target directory
TARGET_DIR="${1:-.}"
cd "$TARGET_DIR"

# Verify git repo
if ! git rev-parse --is-inside-work-tree &>/dev/null; then
    echo -e "${RED}Error:${RESET} Not a git repository: $TARGET_DIR"
    exit 1
fi

echo -e "${BOLD}devpulse${RESET} - project health for ${BLUE}$(basename "$(pwd)")${RESET}"
echo ""

# Current branch
BRANCH=$(git branch --show-current 2>/dev/null || echo "detached")
echo -e "${BOLD}Branch:${RESET}  ${GREEN}$BRANCH${RESET}"

# Last commit
LAST_COMMIT_MSG=$(git log -1 --pretty=format:"%s" 2>/dev/null || echo "no commits")
LAST_COMMIT_TIME=$(git log -1 --pretty=format:"%ar" 2>/dev/null || echo "never")
echo -e "${BOLD}Last commit:${RESET} $LAST_COMMIT_MSG (${YELLOW}$LAST_COMMIT_TIME${RESET})"

# Uncommitted changes
CHANGED_FILES=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
if [[ "$CHANGED_FILES" -eq 0 ]]; then
    echo -e "${BOLD}Changes:${RESET} ${GREEN}clean${RESET}"
else
    echo -e "${BOLD}Changes:${RESET} ${YELLOW}$CHANGED_FILES uncommitted file(s)${RESET}"
fi

# TODO/FIXME count (excluding hidden dirs and common dependency dirs)
TODO_COUNT=$(grep -r --include="*.{sh,py,js,ts,go,rs,rb,java,c,cpp,h,md}" \
    -l "TODO\|FIXME" . \
    --exclude-dir=node_modules \
    --exclude-dir=.git \
    --exclude-dir=vendor \
    --exclude-dir=venv \
    --exclude-dir=__pycache__ \
    --exclude-dir=dist \
    --exclude-dir=build \
    2>/dev/null | wc -l | tr -d ' ')
echo -e "${BOLD}TODOs:${RESET}   ${TODO_COUNT} file(s) with TODO/FIXME markers"

echo ""

Your devpulse script is working and you have hands-on experience with three of Warp's most powerful agentic features. Next up, you will use interactive code review to refine the script further and install it to your PATH.

Review and Iterate with Interactive Code Review

Coding agents can generate hundreds of lines in seconds. But shipping that code without review is risky.

Warp's interactive code review pane gives you a pull-request-style workflow inside the terminal. You can inspect diffs, leave inline comments on specific lines, batch your feedback, and send it all back to Claude Code in one pass. The agent addresses your comments and returns an updated diff for verification.

In this step, get ready to:

• Open the interactive code review pane and browse Claude Code's changes.
• Leave inline comments and send structured feedback to the agent.
• Verify the final result and install the script to your PATH.

Open the code review pane

After Claude Code finishes building your script, all the file changes it made exist as uncommitted diffs in your git repository. The code review pane surfaces these diffs in a visual format grouped by file.

• Open the code review pane by pressing CMD+Shift++ (macOS).
• Alternatively, click the Review changes button at the bottom of the agent conversation, or click the diff chip in the terminal input bar.
• Browse the file changes in the panel. Additions appear highlighted in green with a + prefix. Removals appear in red with a - prefix.

What is the code review pane?

Warp's code review pane works like a pull request review built directly into the terminal. It requires a Git-indexed directory to function. Every change Claude Code made to your project shows up as a visual diff, letting you inspect what was generated before accepting or requesting changes.

This keeps you in control of agent-generated code without switching to a separate editor or Git GUI.

You should see the devpulse script listed in the code review panel with all the lines Claude Code generated highlighted as additions.

Don't see any diffs?

Make sure your project directory is a git repository. The code review pane only works in Git-indexed directories. If you haven't initialized git yet, run git init in the terminal pane, then try opening the code review pane again.

Also confirm that Claude Code's changes are uncommitted. If you already committed them, the panel shows no diffs because there is nothing pending.

help me open the code review pane in Warp

Leave inline comments and send back to the agent

Instead of describing what you want in a freeform chat message, inline comments anchor your feedback to exact lines. Claude Code receives the file, line number, and your note together, so it knows precisely what to fix.

• In the code review panel, find the TODO-counting logic (the grep command section near the bottom of the diff).
• Click the Add comment button on the grep line.
• Type a comment like: "Ensure this excludes node_modules and all hidden directories (anything starting with a dot). Also exclude common dependency directories like vendor, venv, and __pycache__."
• Scroll to the last-commit section and click Add comment on the line that displays the commit time.
• Type a comment like: "Use a human-readable relative format (e.g. '2 hours ago') instead of raw seconds or timestamps. Git's %ar format does this."
• Once you have both comments added, click Submit to send the entire batch to Claude Code in one pass.

Why batch comments instead of sending one at a time?

Warp batches all your inline comments and submits them together. The agent receives your complete feedback, applies changes in one iteration, and returns an updated diff for verification. This is more efficient than sending individual messages because the agent can plan all the fixes together and avoid conflicts between changes.

Claude Code processes your comments and updates the script. You should see an updated diff appear in the code review panel showing the changes it made in response.

Agent not responding to comments?

Make sure the Claude Code session is still active in the agent pane. If the session ended, start a new one and resubmit your comments. The code review panel sends comments to the running agent session in that pane.

help me send inline code review comments to Claude Code in Warp

Verify the final result

After Claude Code addresses your review, you need to verify the script works correctly and then make it available system-wide.

• Switch to the terminal pane and run the script to confirm the improvements by running:

./devpulse .

What should I see?

The script should display colored output with your branch name, last commit message with a human-readable time (like "2 hours ago"), uncommitted change count, and TODO/FIXME file count. The TODO count should correctly exclude node_modules, hidden directories, and other dependency folders.

• Return to the code review pane with CMD+Shift++ to verify the final diff looks clean. Confirm there are no unexpected changes or leftover debug code.
• Install the script to your PATH so you can run it from any directory:

sudo cp devpulse /usr/local/bin/devpulse

What does this command do?

This copies your devpulse script to /usr/local/bin/, which is a standard location on macOS that is already in your PATH. After this, you can run devpulse from any directory without specifying the full path.

The sudo prefix is required because /usr/local/bin/ is a system directory that needs elevated permissions to write to.

• Enter your macOS password when prompted.
• Verify the script is accessible from anywhere by running:

cd ~ && devpulse --help

You should see the help message output, confirming that devpulse runs correctly from your home directory (outside the project).

Permission denied or command not found?

If you see "permission denied", make sure the script is executable. Run sudo chmod +x /usr/local/bin/devpulse to fix permissions.

If you see "command not found", check that /usr/local/bin is in your PATH by running echo $PATH. If it is not listed, you can use ~/.local/bin/ as an alternative location instead.

help me install my devpulse script to PATH on macOS

You have a finished CLI tool, reviewed and refined using Warp's interactive code review workflow. The pull-request-style loop of comment, submit, and verify keeps you in control of agent-generated code without ever leaving the terminal. Next up, you will push this workflow further with multi-agent orchestration.

✔️ Awesome, I've got everything!

Great. Double check you have devpulse installed and working from any directory before moving on.

ⓧ I'd like to double check the full code

Here is the complete devpulse script you should have at this point:

#!/usr/bin/env bash
set -euo pipefail

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
BOLD='\033[1m'
RESET='\033[0m'

# Help message
if [[ "${1:-}" == "--help" || "${1:-}" == "-h" ]]; then
    echo "Usage: devpulse [directory]"
    echo ""
    echo "Show project health: branch, last commit, uncommitted changes, and TODOs."
    echo ""
    echo "Arguments:"
    echo "  directory    Project directory to check (default: current directory)"
    exit 0
fi

# Target directory
TARGET_DIR="${1:-.}"
cd "$TARGET_DIR"

# Verify git repo
if ! git rev-parse --is-inside-work-tree &>/dev/null; then
    echo -e "${RED}Error:${RESET} Not a git repository: $TARGET_DIR"
    exit 1
fi

echo -e "${BOLD}devpulse${RESET} - project health for ${BLUE}$(basename "$(pwd)")${RESET}"
echo ""

# Current branch
BRANCH=$(git branch --show-current 2>/dev/null || echo "detached")
echo -e "${BOLD}Branch:${RESET}  ${GREEN}$BRANCH${RESET}"

# Last commit
LAST_COMMIT_MSG=$(git log -1 --pretty=format:"%s" 2>/dev/null || echo "no commits")
LAST_COMMIT_TIME=$(git log -1 --pretty=format:"%ar" 2>/dev/null || echo "never")
echo -e "${BOLD}Last commit:${RESET} $LAST_COMMIT_MSG (${YELLOW}$LAST_COMMIT_TIME${RESET})"

# Uncommitted changes
CHANGED_FILES=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')
if [[ "$CHANGED_FILES" -eq 0 ]]; then
    echo -e "${BOLD}Changes:${RESET} ${GREEN}clean${RESET}"
else
    echo -e "${BOLD}Changes:${RESET} ${YELLOW}$CHANGED_FILES uncommitted file(s)${RESET}"
fi

# TODO/FIXME count (excluding hidden dirs and common dependency dirs)
TODO_COUNT=$(grep -r --include="*.{sh,py,js,ts,go,rs,rb,java,c,cpp,h,md}" \
    -l "TODO\|FIXME" . \
    --exclude-dir=node_modules \
    --exclude-dir=.git \
    --exclude-dir=vendor \
    --exclude-dir=venv \
    --exclude-dir=__pycache__ \
    --exclude-dir=dist \
    --exclude-dir=build \
    2>/dev/null | wc -l | tr -d ' ')
echo -e "${BOLD}TODOs:${RESET}   ${TODO_COUNT} file(s) with TODO/FIXME markers"

echo ""

Secret mission

Orchestrate Parallel Agent Subtasks

You have been steering a single Claude Code session like a pro. But what if you could break a complex enhancement into three parallel subtasks and have multiple agents work on them simultaneously? Use Warp's /orchestrate command to coordinate three subagents, each tackling a different feature addition to your devpulse script.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally, so there are no ongoing costs. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

• ~/.warp/tab_configs/devpulse_workspace.toml - your reusable Tab Config.
• settings.toml modifications - power-user defaults for vertical tabs, prompt queueing, and Rich Input.
• /usr/local/bin/devpulse - the CLI script installed to your PATH.

Keep everything running

No action needed. Choose this if you are still actively building or want to keep using your power-user Warp configuration.

• Your settings.toml changes persist across Warp sessions. Warp hot-reloads them every time it starts.
• Your Tab Config stays in the + menu permanently until you remove it.
• The devpulse script remains available as a command from any terminal session.

Pause - I'll come back to this later

Revert your global Warp settings changes to return to default behavior, but keep the Tab Config and script for later use.

• Open settings.toml in Warp (Settings > scroll to bottom > click "Open settings file").
• Delete or comment out the [appearance.vertical_tabs], [agent], and [rich_input] sections you added.
• Save the file. Warp hot-reloads immediately, reverting to default behavior.
• Your Tab Config and devpulse script remain in place for when you return.

Delete - I don't want to use this again

Remove all project resources and return Warp to its previous state.

• Remove the Tab Config by running:

rm ~/.warp/tab_configs/devpulse_workspace.toml

• Remove the devpulse script from your PATH by running:

rm /usr/local/bin/devpulse

• If you also created a project directory for the script source, remove it by running:

rm -rf ~/Desktop/devpulse

• Revert your Warp settings by opening settings.toml (Settings > scroll to bottom > "Open settings file") and deleting the [appearance.vertical_tabs], [agent], and [rich_input] sections you added.
• Save the file. Warp hot-reloads immediately.

Nice Work!

Nice Work!

You just transformed your Warp Terminal from a daily driver into a fully automated, agentic power-user workspace. You configured Warp programmatically, built a one-click workspace launcher, and steered Claude Code through an entire CLI tool build using nothing but Warp's native features.

Here's what you learned:

• Configured Warp programmatically via settings.toml with vertical tabs in expanded mode, prompt queueing defaults, and Rich Input auto-behavior.
• Built a parameterized Tab Config that launches a multi-pane Claude Code workspace in one click from the + menu.
• Steered Claude Code end-to-end using Rich Input (Ctrl-G) for complex prompts, prompt queueing (CMD+Shift+J) for chained tasks, and blocks as context (CMD-UP) for zero-copy debugging.
• Secret Mission: Orchestrated parallel subtasks with /orchestrate, monitoring multiple subagents via vertical tabs and merging results through interactive code review.

Ready to quiz yourself?