Debugging
Debug code with Verdent's AI-powered debugging workflows
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
Describe the Bug
In the input box, describe the issue and symptoms you're seeing
Verdent Investigates
Verdent reads relevant files and analyzes the code to find the root cause
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+JorCtrl+`to toggle the terminal panel - Terminal opens in the current workspace's root directory
Common terminal debugging commands
# 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=srcUsing @verifier
The @verifier subagent specializes in rapid validation and verification tasks.
When to Use @verifier
| Task | Example |
|---|---|
| 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 fieldsValidate after changes:
@verifier run the tests for the auth module and summarize any failuresQuick sanity check:
@verifier is the database connection being properly closed in @dbClient.ts?@verifier vs Main Agent
| Aspect | @verifier | Main Agent |
|---|---|---|
| Context | Isolated, focused | Full conversation context |
| Speed | Faster for quick checks | Better for complex analysis |
| Best for | Validation, verification | Investigation, fixing |
| Cost | Separate 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:
- Analyze the error message
- Search for relevant code
- Identify the root cause
- Propose a fix
Debug failing tests:
Prompt template:
The test @tests/auth.test.ts is failing on line 45.
The test expects [expected behavior] but gets [actual behavior].Verdent will:
- Read the test file
- Analyze what's being tested
- Check the implementation
- Identify the discrepancy
- Propose fix (to test or implementation)
Profile and optimize slow code:
Prompt template:
The @processOrders function is running slowly.
Profile and suggest optimizations.Verdent may:
- Add timing logs
- Run profiling commands
- Identify bottlenecks
- Suggest optimizations
Desktop Debugging Features
Parallel Debugging
Debug multiple issues simultaneously in separate workspaces:
Debug unrelated bugs in parallel without interference:
Create Debug Workspace
Click New Workspace in the Top Bar for your first bug
Name the Workspace
Give it a descriptive name (e.g., "debug-auth-bug")
Describe the Bug
In the input box, describe the bug and ask Verdent to investigate
Create Additional Workspaces
Repeat for each additional bug you want to debug
Compare Results
Switch between workspaces using All Workspaces to compare behavior
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.
Debug while keeping a stable reference:
Keep Base Workspace Stable
Your base workspace stays on master with working code
Create Debug Workspace
Click New Workspace for your debug investigation
Investigate the Bug
Let Verdent add logging, make changes, and test fixes
Compare Behavior
Run tests in both workspaces to compare results
Apply or Discard
Rebase the fix if successful, or delete the workspace to discard
Benefit: Always have stable code to compare against during investigation.
Reviewing Bug Fixes
After Verdent makes a fix:
- Click Task Changes in the middle panel to review changes
- Verify the fix addresses the root cause
- Check for unintended side effects
- Request modifications in the input box if needed
Plan Mode for Complex Bugs
For difficult-to-understand bugs:
Switch to Plan Mode
Press Shift+Tab or Ctrl+. to switch to Plan Mode
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.Review Analysis
Verdent analyzes code and creates an investigation plan
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.tsRequest deep investigation of an issue:
Help me debug why @userService.createUser fails silently when
the database connection is lost. I need to understand:
1. Where the error is being swallowed
2. Why no error is logged
3. How to add proper error handlingGenerate tests after fixing a bug:
The bug in @paymentProcessor.ts was fixed.
Generate regression tests to prevent this from happening again.FAQs
How do I debug intermittent bugs?
- Add logging to capture state when bug occurs
- Request Verdent to add strategic log statements
- Reproduce multiple times to find pattern
- Use
@verifierto validate fixes don't introduce regressions
Should I use a separate workspace for debugging?
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
How do I debug production issues safely?
- Create a workspace for the debug effort
- Add logging/diagnostics without deployment
- Test fixes thoroughly
- Review changes before rebasing
- Deploy after full test verification
When should I use @verifier instead of the main agent?
Use @verifier for quick validation checks, syntax verification, and pre-commit checks. Use the main agent for complex investigations requiring full context.
Can Verdent debug code it didn't write?
Yes. Describe the bug and use @-mentions to point Verdent to relevant files. Verdent analyzes the code regardless of who wrote it.