Daily Workflows with Vibe

A Routine Tool, Not an Exception

Vibe isn’t a tool you fire up only when you’re stuck. It’s designed to fit seamlessly into your everyday development workflow. This lesson covers the most productive use cases, drawn from real-world developer practices.

Preparing and Submitting a Pull Request

The path from writing code to opening a pull request is repetitive, which makes it prime for delegation. Start by asking Vibe to review your work:

Summarize the changes I've made since the last commit. 
Are there any quality or security issues?

The agent runs git diff, analyzes the modified code, and returns structured feedback: potential bugs, possible improvements, and style deviations. You fix what needs fixing, then ask for a conventional commit message. Vibe generates text in the Conventional Commits format—feat:, fix:, refactor:—aligned with the actual diff content. The final step is a single sentence: “Create a pull request with a clear title and a detailed description of the changes.” If the GitHub CLI (gh) is installed, the agent pushes the branch and opens the PR for you.

Documenting What You Left Behind

Here’s a less obvious use case: documenting shell aliases you’ve accumulated over the years. If your .bashrc or .zshrc contains dozens of shortcuts whose original purpose no one remembers, a single prompt fixes that.

Read my @~/.zshrc file and document every alias you find. 
For each one, explain what it does and add a comment above it.

Vibe parses the file, isolates the aliases, infers their function, and adds a descriptive comment above each one. Your config file becomes maintainable again at zero attention cost.

Debugging in Successive Steps

When an error strikes, the most effective reflex is to feed the raw error message and its context directly to the agent:

I get this error when starting the server:
TypeError: Cannot read properties of undefined (reading 'map')
Find where this comes from and fix it

The agent searches for places where .map() is called, identifies cases where the variable might be undefined, and proposes a fix with a null check. For trickier bugs, diagnosis happens over several turns, each building on the previous result.

> The integration test user.test.ts is failing. Run it and show me the error.
< [Runs the test, displays the error]
< The assertion on line 42 fails: expected 200 but got 401...

> Why is the status 401? Check the authentication middleware.
< [Reads the middleware, analyzes the flow]
< The JWT token isn't passed in the test headers...

> Fix the test to include the token
< [Proposes the modification with the diff]

This workflow mirrors how a developer debugs—observe, hypothesize, verify—but each loop takes seconds instead of minutes.

Steering a Large Refactor

Large-scale refactorings rarely fail due to technical difficulty; they fail because you lose the thread. Vibe’s todo list solves this. First, have it establish a plan:

Create a plan to migrate this project from JavaScript to TypeScript. 
List all necessary steps.

Vibe produces an ordered sequence of tasks. You tackle them one by one—“Start with the first step of the plan”—checking progress with Cmd+\ (macOS) or Alt+\, which shows what’s done and what remains. This lets you resume work three days later without having to reconstruct where you left off.

Getting Up to Speed on an Unknown Project

Onboarding is where the payoff is most visible: a well-framed question replaces hours of documentation reading.

I just joined this project. Give me a complete briefing:
- Overall architecture
- Technologies used
- Main entry points
- How to run the project locally
- Tests: how to run them and current coverage

In the same spirit, test generation is straightforward: “Generate unit tests for @src/services/payment.ts covering normal cases and error cases.” The agent reads the code, identifies execution paths, writes assertions, and automatically adapts to the project’s framework, whether it’s Jest, Vitest, or Pytest.

Automating Repetitive Tasks

Everything so far has been interactive, but recurring checks benefit from becoming scripts via programmatic mode.

# Daily check script
vibe --prompt "Check for npm vulnerabilities and summarize critical issues" \
     --output json \
     --max-turns 5

# Code analysis before commit (pre-commit hook)
vibe --prompt "Verify that modified code follows project conventions" \
     --max-price 0.10 \
     --output text

Don’t forget the two guardrails here: --max-turns and --max-price, which cap the number of exchanges and the session cost, respectively. Without them, an unsupervised agent running in a pre-commit hook could loop for a long time—and get expensive.

Key Takeaways

• Vibe accelerates PR preparation with automated analysis, commit messages, and creation
• Interactive debugging enables progressive, targeted diagnosis
• The task list (Cmd+\ or Alt+\) tracks progress on complex refactorings
• Programmatic mode (--prompt, --output json) enables automation in scripts
• New project exploration provides fast, structured onboarding