Use Verdent to identify and fix bugs through natural language descriptions. Verdent analyzes your code, identifies root causes, and implements fixes automatically.

​
What You’ll Learn

  • Debug issues by describing them to Verdent
  • Leverage the @verifier subagent for quick checks
  • Apply systematic debugging workflows
  • Use Desktop features for parallel debugging

​
Debugging with Verdent

​
Basic Debugging Workflow

1

Describe the Bug

In the input box, describe the issue and symptoms you’re seeing
2

Verdent Investigates

Verdent reads relevant files and analyzes the code to find the root cause
3

Review the Fix

Verdent proposes and implements the fix, then shows the changes

​
Terminal (Optional)

For manual debugging or when you need direct command access:
  • Press Ctrl+J or Ctrl+` to toggle the terminal panel
  • Terminal opens in the current workspace’s root directory
# Run tests
npm test
pytest
go test ./...

# Run tests with verbose output
npm test -- --verbose
pytest -v

# Run specific test file
npm test -- src/auth.test.ts
pytest tests/test_auth.py

# Run with coverage
npm test -- --coverage
pytest --cov=src

​
Using @verifier

The @verifier subagent specializes in rapid validation and verification tasks.

​
When to Use @verifier

TaskExample
Quick checks@verifier check if auth middleware handles expired tokens
Validation@verifier validate the error handling in @userService.ts
Syntax verification@verifier check this SQL query for syntax errors
Pre-commit checks@verifier verify the changes are ready for commit

​
@verifier Examples

Check specific functionality: 
@verifier verify that the login function properly handles:
- Invalid credentials
- Locked accounts
- Missing required fields
Validate after changes: 
@verifier run the tests for the auth module and summarize any failures
Quick sanity check: 
@verifier is the database connection being properly closed in @dbClient.ts?

​
@verifier vs Main Agent

Aspect@verifierMain Agent
ContextIsolated, focusedFull conversation context
SpeedFaster for quick checksBetter for complex analysis
Best forValidation, verificationInvestigation, fixing
CostSeparate context (efficient)Main context usage
@verifier can be configured to use a different model in Settings. Use a smaller, cheaper model for simple verification tasks to reduce credit usage.

​
Debugging Workflows

Investigate error messages systematically:Prompt template:
I'm seeing this error: [paste error message]
It occurs when [describe when/how it happens]

Help me understand what's causing it and how to fix it.
Verdent will:
  1. Analyze the error message
  2. Search for relevant code
  3. Identify the root cause
  4. Propose a fix

​
Desktop Debugging Features

​
Parallel Debugging

Debug multiple issues simultaneously in separate workspaces:
Debug unrelated bugs in parallel without interference:
1

Create Debug Workspace

Click New Workspace in the Top Bar for your first bug
2

Name the Workspace

Give it a descriptive name (e.g., “debug-auth-bug”)
3

Describe the Bug

In the input box, describe the bug and ask Verdent to investigate
4

Create Additional Workspaces

Repeat for each additional bug you want to debug
5

Compare Results

Switch between workspaces using All Workspaces to compare behavior
6

Apply Fixes

When a fix is ready, click Workspace Actions → Rebase to main branch
Benefit: Each debug effort is isolated with no interference between sessions.

​
Reviewing Bug Fixes

After Verdent makes a fix:
  1. Click Task Changes in the middle panel to review changes
  2. Verify the fix addresses the root cause
  3. Check for unintended side effects
  4. Request modifications in the input box if needed

​
Plan Mode for Complex Bugs

For difficult-to-understand bugs:
1

Switch to Plan Mode

Press Shift+Tab or Ctrl+. to switch to Plan Mode
2

Describe the Bug

In the input box, describe the bug in detail:
I have a race condition in the order processing system.
Sometimes orders are processed twice.
Help me understand what's happening and plan a fix.
3

Review Analysis

Verdent analyzes code and creates an investigation plan
4

Execute Investigation

Switch to Agent Mode to investigate systematically

​
Debugging Prompts

Structured format for reporting bugs:
Bug: [Brief description]

Steps to reproduce:
1. [Step 1]
2. [Step 2]
3. [Step 3]

Expected: [What should happen]
Actual: [What actually happens]

Relevant files: @file1.ts @file2.ts

​
FAQs

  1. Add logging to capture state when bug occurs
  2. Request Verdent to add strategic log statements
  3. Reproduce multiple times to find pattern
  4. Use @verifier to validate fixes don’t introduce regressions
Yes, for:
  • Bugs that might require significant changes
  • When you want to compare against master
  • Long debugging sessions
No, for:
  • Quick fixes
  • Obvious bugs with simple solutions
  • When already in a feature workspace
  1. Create a workspace for the debug effort
  2. Add logging/diagnostics without deployment
  3. Test fixes thoroughly
  4. Review changes before rebasing
  5. Deploy after full test verification
Use @verifier for quick validation checks, syntax verification, and pre-commit checks. Use the main agent for complex investigations requiring full context.
Yes. Describe the bug and use @-mentions to point Verdent to relevant files. Verdent analyzes the code regardless of who wrote it.

​
See Also

Subagent Management

Learn about @verifier and other subagents

Error Recovery

Handling errors and recovery strategies