Verdent

https://docs.verdent.ai
Admin
Verdent is an AI-powered coding assistant that uses a plan-code-verify workflow to turn ideas into...
Tokens:87,107
Snippets:933
Trust Score:7.2
Update:9 months ago
Show doc for...
Tokens:
Raw
### Example Prompts for Verdent AI Analysis

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

These prompts can be entered into the Verdent AI input box within VS Code to analyze your project. They demonstrate Verdent's ability to understand project structure, technologies, dependencies, and identify entry points without modifying files.

```text
What kind of project is this?
```

```text
Explain what this project does
```

```text
What dependencies does this project have?
```

```text
Show me the main entry point of this application
```

--------------------------------

### Install Verdent Extension via Command Line

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/installation

Installs the Verdent extension for VS Code using the command line interface. This method is efficient for automated setups, remote installations, and bulk deployments.

```bash
code --install-extension verdentai.verdent

```

--------------------------------

### Prompt for File Creation with Verdent AI

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

This prompt instructs Verdent AI to create a new text file named 'hello_world.txt' containing a simple greeting message. This demonstrates Verdent's code generation capabilities.

```text
Create a hello_world.txt file with a greeting message
```

--------------------------------

### Applying Preferred Code Structure (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Illustrates how to guide the AI to adopt a specific code structure or pattern by providing an example and requesting its application across components. This is useful for maintaining code style consistency.

```text
The component structure is close, but use this pattern instead:
[paste example of your preferred structure]
Apply this same pattern to the remaining components
```

--------------------------------

### Project Rules Example (AGENTS.md - Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

An example of AGENTS.md, used for project-specific coding standards and conventions. This file is stored in the project's root directory and is version-controlled.

```markdown
# AGENTS.md

## Dev environment tips
- Use `pnpm dlx turbo run where <project_name>` to navigate
- Run `pnpm install --filter <project_name>` for dependencies
- Check package.json name field for correct package name

## Testing instructions
- Run `pnpm turbo run test --filter <project_name>`
- From package root: `pnpm test`
- Focus on one test: `pnpm vitest run -t "<test name>"`
- Fix all errors before merge

## PR instructions
- Title format: [<project_name>] <Title>
- Always run `pnpm lint` and `pnpm test` before committing
```

--------------------------------

### Plan Customization Rules Example (plan_rules.md - Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

An example of plan_rules.md, which controls the output format and detail level of Verdent's Plan Mode. This file is stored at `~/.verdent/plan_rules.md`.

```markdown
# Plan Rules

## Plan Structure
- Start with brief summary (2-3 sentences)
- Include estimated time for each major step
- List prerequisites before implementation steps
- Identify potential risks

## Level of Detail
- Break tasks into subtasks of 15-30 minutes
- Include specific file paths for modifications
- List functions/components to create/modify

## Format
- Use numbered lists for sequential steps
- Use bullet points for options
- Include code snippets for complex changes
```

--------------------------------

### Plan Rules Application Example in Plan Mode

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Demonstrates how different rule types are applied sequentially during Plan Mode generation. user_rules.md and AGENTS.md influence code and approach, while plan_rules.md affects the plan's format.

```text
Plan Mode activated:
1. user_rules.md: "Use TypeScript" → Applied to code in plan
2. AGENTS.md: "Follow project conventions" → Applied to approach
3. plan_rules.md: "Include time estimates" → Applied to plan format
→ Result: Plan shows TypeScript code following project conventions with time estimates
```

--------------------------------

### Vue Component Example (Vue.js)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Illustrates a Vue 3 single-file component using the `<script setup>` syntax for a user profile. It defines a 'user' prop and displays the user's name and email within the template. This showcases typical Vue component structure.

```vue
<template>
  <div class="profile">
    <h1>{{ user.name }}</h1>
    <p>{{ user.email }}</p>
  </div>
</template>

<script setup>
defineProps(['user']);
</script>
```

--------------------------------

### Exploratory Prompts for Codebase Understanding

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

Initiate code analysis by asking Verdent to explore specific aspects of your project, such as database schemas or authentication flows. This helps Verdent build context for more accurate suggestions.

```plaintext
Analyze the database schema
Explain the authentication flow
```

--------------------------------

### Subagent System Prompt Examples (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/subagent-management

Examples of defining subagent behavior and decision-making principles using Markdown format within a system prompt. This includes specifying analysis approaches, personalities, decision-making criteria, and output formats.

```markdown
Analysis approach:
- Profile before optimizing
- Focus on algorithmic improvements
- Provide before/after benchmarks
```

```markdown
You are a performance optimization specialist.
```

```markdown
When suggesting optimizations:
1. Measure first, optimize second
2. Prioritize readability over micro-optimizations
3. Only suggest changes with >10% performance improvement
```

```markdown
Output format:
- Markdown tables for endpoints
- Code examples in multiple languages
- Authentication flow diagrams
```

--------------------------------

### Using Plan Mode for Unfamiliar Code Refactoring

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

When encountering unfamiliar code, use Plan Mode to outline refactoring steps before implementation. This allows for review and clarification, ensuring confidence before execution.

```plaintext
Refactor the authentication module to use async/await instead of callbacks
```

--------------------------------

### Example: Database Migration Reviewer Subagent

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

An example of a custom subagent for reviewing database migrations. It includes a system prompt detailing a checklist for migration safety, risk assessment criteria, and specific usage guidelines.

```markdown
---
name: migration-reviewer
description: Reviews database migrations for safety and correctness
---
# System Prompt

You are a database migration safety specialist.

Review checklist:
- Check for destructive operations (DROP, DELETE without WHERE)
- Verify reversible migrations (up/down compatibility)
- Identify potential data loss scenarios
- Validate index creation strategies
- Check for blocking operations on large tables

Risk assessment:
- Categorize migrations: low/medium/high risk
- Recommend staging environment testing for high-risk changes
- Suggest rollback procedures

Invocation policy (strict): Only run when explicitly requested.

When to use:
- User creates or modifies migration files
- Pre-deployment migration review
- Investigating migration failures

When NOT to use:
- Schema design from scratch
- Query optimization

```

--------------------------------

### Example Debugging Conversation with Verdent AI

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Demonstrates how to explicitly ask Verdent AI about the rules it is following for a specific behavior, helping to identify rule conflicts or misunderstandings.

```text
You: "Which rule are you following for indentation?"
Verdent: "I'm using 4-space indentation from AGENTS.md (line 12),
which overrides your user_rules.md preference for 2-space indentation."
```

--------------------------------

### Rule Writing Best Practice Example (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

Illustrates specific and directive rule writing compared to vague statements, emphasizing clarity and effectiveness in Verdent's rule files.

```markdown
```
✓ Good: "Always use async/await for asynchronous operations"
✗ Vague: "Try to use modern JavaScript"
```
```

--------------------------------

### Reference Implementation Patterns

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Point to existing code as implementation examples for new features. This ensures new implementations maintain consistency with established conventions, making the codebase more maintainable and predictable by following the pattern of a specified existing file.

```text
Implement the new ProductService following the same pattern as UserService.js, including error handling, validation, and database transaction management
```

--------------------------------

### Example: API Documentation Generator Subagent

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

An example of a custom subagent designed to generate API documentation. It specifies the subagent's name, description, a detailed system prompt outlining its documentation approach, and an invocation policy.

```markdown
---
name: api-documenter
description: Generates comprehensive API documentation from code
---
# System Prompt

You are an API documentation specialist.

Documentation approach:
- Extract endpoints, parameters, and responses from code
- Generate OpenAPI/Swagger specifications
- Include usage examples and error codes
- Document authentication requirements

Output format:
- Markdown tables for endpoints
- Code examples in multiple languages
- Authentication flow diagrams

Invocation policy (strict): Only run when explicitly requested.

When to use:
- User requests API documentation generation
- Need to document REST/GraphQL endpoints
- Creating developer guides

When NOT to use:
- Inline code comments
- User-facing documentation

```

--------------------------------

### User Rules Example (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

An example of user_rules.md, which defines global preferences for coding style, organization, documentation, and communication across all Verdent projects. This file is stored at `~/.verdent/user_rules.md`.

```markdown
# User Rules

## TypeScript Preferences
- Use strict mode in tsconfig.json
- Prefer interfaces over type aliases
- Include return types on all functions

## Code Organization
- One component per file
- Named exports instead of default exports
- Organize imports: external, internal, types

## Documentation
- TSDoc comments for public APIs
- Include @param and @returns tags

## Communication
- Provide explanations before showing code
- Highlight breaking changes explicitly
```

--------------------------------

### UI Testing Workflow Example

Source: https://docs.verdent.ai/verdent-for-vscode/core-features/browser-tool

Demonstrates a common use case for UI testing, involving launching a browser, performing login actions (clicking fields, typing credentials), submitting a form, and implicitly verifying results via subsequent actions or screenshots.

```text
Launch browser at https://app.example.com/login
Click coordinates 450,280
Type "testuser@example.com"
Click coordinates 450,340
Type "password123"
Click coordinates 500,420
Close browser
```

--------------------------------

### Effective Refactoring Request Examples

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/refactoring

Examples of how to describe refactoring goals focusing on outcomes and desired improvements, rather than specific implementation details. These prompts guide Verdent AI to analyze the code and propose suitable refactoring strategies.

```plaintext
Refactor the UserController to improve readability and reduce duplication
```

```plaintext
This authentication logic is scattered across multiple files. Consolidate it into a single module
```

```plaintext
Improve error handling in the API layer to be more consistent and informative
```

--------------------------------

### Efficient File Reading with file_read

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/tool-reference

Demonstrates efficient file reading by specifying line ranges for large files to avoid excessive context consumption. Includes examples of both efficient and less efficient approaches.

```bash
# Good: Read specific section
file_read("large-config.json", start_line=100, max_lines=50)

# Less efficient: Read entire large file
file_read("large-config.json")  # May consume excessive context
```

--------------------------------

### Content Navigation Example

Source: https://docs.verdent.ai/verdent-for-vscode/core-features/browser-tool

Shows how to navigate through web content that requires interaction, such as clicking menus or loading additional content via scrolling. This enables access to target content before extraction or further processing.

```text
Launch browser at https://store.example.com
Scroll down three times
Click "Next Page" at 960,800
Close browser
```

--------------------------------

### Safe Bash Command Execution

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/tool-reference

Provides examples of safe and efficient bash command execution, including setting timeouts and chaining dependent commands. Highlights the importance of clear summaries.

```bash
# Good: Clear summary, reasonable timeout
bash("npm run build", timeout=120000, summary="Build production bundle")

# Good: Chained dependencies
bash("npm install && npm run test", timeout=180000)
```

--------------------------------

### Clarifying Vague Rules Example

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Addresses the issue of ambiguous rules by providing an example of a vague rule ('Write good tests') and a proposed fix that makes the rule specific and measurable ('Generate unit tests with 80%+ coverage, include edge cases').

```text
"Write good tests"
→ Problem: What is "good"?
→ Fix: "Generate unit tests with 80%+ coverage, include edge cases"
```

--------------------------------

### Screenshot Capture Example

Source: https://docs.verdent.ai/verdent-for-vscode/core-features/browser-tool

Illustrates how to capture screenshots for documentation purposes. By navigating to specific pages and scrolling to relevant sections, users can build visual documentation. Screenshots are automatically generated after each action.

```text
Launch browser at https://docs.example.com
Scroll down to API section
Close browser
```

--------------------------------

### Specific Request Prompting for Bug Fixing

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

Improve accuracy by providing detailed information when requesting bug fixes. Instead of a generic request, specify the bug, the file, and the user-observed behavior.

```plaintext
fix the login bug in `LoginForm.tsx` where users see a blank screen after entering wrong credentials
```

--------------------------------

### Refining Rules in AGENTS.md for Clarity

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Shows an example of how to refine contradictory or overly broad rules within a single file (AGENTS.md) to provide clearer instructions for Verdent. This involves adding context-specific conditions to rules.

```markdown
- Prefer functional components for simple UI
- Use functional components with hooks for complex state
- Only use class components for legacy code maintenance
```

--------------------------------

### Contextual Referencing with @-mentions

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

Direct Verdent's focus by explicitly mentioning files or components using the '@' symbol. This ensures that subsequent commands are applied to the intended context.

```plaintext
@components/UserProfile.tsx refactor this component to use hooks
```

--------------------------------

### Handle Binary Files with External Tools (Bash)

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/common-issues

This snippet demonstrates how to modify binary files like images and PDFs by invoking external command-line tools using bash. It requires appropriate tools to be installed on the system.

```bash
# Use bash to call external tools
bash("convert input.png -resize 50% output.png")
bash("pdftotext document.pdf output.txt")
```

--------------------------------

### Manage Large Files with Line Ranges and Grep (Bash)

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/common-issues

This example shows how to handle files exceeding 10,000 lines by specifying line ranges for reading and using grep for targeted searching. This prevents context issues caused by overly large inputs.

```bash
# Always use line ranges for large files
file_read("large.log", start_line=1000, max_lines=100)

# Search first to find relevant sections
grep_content("ERROR", glob="large.log")
```

--------------------------------

### Troubleshoot MCP Server Environment Variables

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

Check the status of environment variables required for the MCP server. This example shows how to display the value of the GITHUB_TOKEN environment variable, which might be necessary for certain configurations.

```shell
echo $GITHUB_TOKEN
```

--------------------------------

### Create, Switch, and Push Git Branches

Source: https://docs.verdent.ai/verdent-for-vscode/common-workflows/version-control

These commands demonstrate how to create new branches, switch between existing branches, and push new branches to a remote repository. Ensure you have Git installed and configured.

```bash
git checkout -b feature/user-notifications
```

```bash
git checkout main
```

```bash
git checkout -b feature/payment-integration
git push -u origin feature/payment-integration
```

--------------------------------

### Best Practices: Specific and Directive Rule Language

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Provides examples of writing clear, imperative rules, contrasting vague suggestions with precise directives. This ensures Verdent AI interprets and applies rules consistently.

```markdown
Good:
- Use async/await for asynchronous operations
- Include JSDoc comments for all exported functions

Avoid:
- Try to use modern JavaScript features
- Add comments when necessary
```

--------------------------------

### Maintain Context Between Todos

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Start new sessions between different todos to maintain fresh context. This prevents contamination from previous task details, ensures focus, and optimizes token usage.

```text
After completing todo #1: "Start a new session"
Then: "Let's work on todo #2 from todos.md"
```

--------------------------------

### Utilizing Subagents for Specialized Tasks

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

Leverage specialized subagents like `@Explorer`, `@Verifier`, and `@Code-reviewer` for specific tasks such as file discovery, code validation, and security reviews. This streamlines complex operations.

```plaintext
@Explorer find all API endpoints in this project
```

--------------------------------

### Incremental Task Breakdown for Complex Features

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/quick-start

Decompose large or multi-step features into smaller, manageable tasks. This approach helps maintain clarity, allows for step-by-step verification, and reduces complexity.

```plaintext
1. Create a new database table for user profiles
2. Create an API endpoint to get and update profiles
```

--------------------------------

### Launch Browser Session

Source: https://docs.verdent.ai/verdent-for-vscode/core-features/browser-tool

Starts a new browser session directed to a specified URL. This is the initial action required for any browser automation workflow. The browser opens with a fixed resolution of 1920x1080.

```text
Launch browser at https://example.com
```

--------------------------------

### Rule Precedence: Project vs. User Rules Conflict

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Illustrates a conflict between user-defined indentation rules and project-specific indentation rules. The example shows that project rules (AGENTS.md) take precedence over user rules (user_rules.md).

```text
user_rules.md: "Use 2-space indentation"
AGENTS.md: "Use 4-space indentation for this project"
→ Result: Verdent uses 4-space indentation (project rules win)
```

--------------------------------

### React Component Example (JavaScript/TypeScript)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Demonstrates a React functional component for displaying user profile information. It takes a 'user' object as a prop and renders the user's name and email. This snippet highlights common patterns in modern React development.

```jsx
function UserProfile({ user }) {
  return (
    <div className="profile">
      <h1>{user.name}</h1>
      <p>{user.email}</p>
    </div>
  );
}
```

--------------------------------

### Formatting Conflict Resolution Example

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

A common scenario where user and project rules conflict on code indentation. The resolution clarifies that AGENTS.md (project standard) wins, and suggests accepting the standard or discussing team alignment.

```text
user_rules.md: "Use 2-space indentation"
AGENTS.md: "Use 4-space indentation"
→ Resolution: AGENTS.md wins (project standard)
→ Fix: Accept project standard or discuss with team
```

--------------------------------

### Check Visual Studio Code Version via Command Line

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/system-requirements

This command checks the installed version of Visual Studio Code. Verdent AI requires version 1.90.0 or higher. Ensure you have VS Code installed and accessible in your system's PATH.

```bash
code --version
```

--------------------------------

### Apply Inline Commit Message Instructions

Source: https://docs.verdent.ai/verdent-for-vscode/common-workflows/version-control

This example shows how to provide one-time instructions for generating a commit message with a specific format, including a ticket number and issue reference. Verdent AI will adhere to these inline instructions for the immediate commit.

```bash
git commit -m "[PROJ-42] Add search functionality

Relates to #42"
```

--------------------------------

### Generate React Components from Design Mockups using Verdent

Source: https://docs.verdent.ai/verdent-for-vscode/common-workflows/images

This example demonstrates using Verdent AI to generate React components based on a visual design mockup. It includes generating component structure, applying Tailwind CSS for styling, and refining the output based on textual feedback. Specify the framework (e.g., React) and styling approach (e.g., Tailwind CSS) for best results.

```tsx
// DashboardLayout.tsx
import React from 'react';
import { StatCard } from './StatCard';
import { RecentActivity } from './RecentActivity';
import { UserChart } from './UserChart';

export function DashboardLayout() {
  return (
    <div className="dashboard-container">
      <div className="stats-grid">
        <StatCard title="Total Users" value="1,234" trend="+12%" />
        <StatCard title="Revenue" value="$45.6K" trend="+8%" />
        <StatCard title="Active Sessions" value="89" trend="-3%" />
      </div>
      <div className="charts-section">
        <UserChart />
      </div>
      <div className="activity-section">
        <RecentActivity />
      </div>
    </div>
  );
}

```

```tsx
<div className="grid grid-cols-3 gap-6 p-6">
  <StatCard className="bg-white rounded-lg shadow-md p-4" ... />
</div>

```

--------------------------------

### Progressive Enhancement of Task CRUD Endpoints (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Demonstrates building complex features incrementally by starting with core functionality (CRUD endpoints) and adding features like pagination, filtering, and search in subsequent steps. This allows for testing at each stage.

```text
Step 1: "Create basic CRUD endpoints for tasks"
Step 2: "Add pagination to the GET endpoint"
Step 3: "Add filtering by status and priority"
Step 4: "Add full-text search across title and description"
```

--------------------------------

### Multiple MCP Servers Configuration

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

Configures multiple MCP servers, including PostgreSQL and GitHub. This setup allows Verdent to interact with both systems concurrently for comprehensive workflow integration.

```json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/myapp_dev"
      ]
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}
```

--------------------------------

### Explain Code Functionality and Structure

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/understanding-code

Verdent explains specific functions or classes by analyzing their implementation, parameters, return values, and usage within the codebase. It details the purpose, inputs, outputs, internal logic, dependencies, and provides usage examples.

```natural_language
Explain the UserAuth class
```

```natural_language
What does the processPayment function do?
```

```natural_language
Break down the ApiService class methods
```

--------------------------------

### Angular Component Example (TypeScript)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Presents an Angular component written in TypeScript, utilizing the `@Component` decorator. It defines a 'user' input property and displays the user's name and email in its template. This reflects standard Angular component implementation.

```tsx
@Component({
  selector: 'user-profile',
  template: `
    <div class="profile">
      <h1>{{ user.name }}</h1>
      <p>{{ user.email }}</p>
    </div>
  `
})
export class UserProfileComponent {
  @Input() user!: User;
}
```

--------------------------------

### JavaScript Unit Tests: Jest, Mocha, Vitest, Jasmine

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/testing-debugging

Examples of unit tests written using popular JavaScript testing frameworks like Jest, Mocha, Vitest, and Jasmine. These snippets demonstrate basic assertion patterns for a 'sum' function.

```javascript
test('sum returns correct result', () => {
  expect(sum(2, 3)).toBe(5);
});
```

```javascript
const assert = require('assert');

describe('sum', () => {
  it('returns correct result', () => {
    assert.strictEqual(sum(2, 3), 5);
  });
});
```

```javascript
import { describe, it, expect } from 'vitest';

it('sum returns correct result', () => {
  expect(sum(2, 3)).toBe(5);
});
```

```javascript
describe('sum', () => {
  it('returns correct result', () => {
    expect(sum(2, 3)).toEqual(5);
  });
});
```

--------------------------------

### Rule Precedence in AGENTS.md vs user_rules.md

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/common-issues

Illustrates the rule precedence between `AGENTS.md` and `user_rules.md`. `AGENTS.md`, located in the project root, has higher priority. This example shows how a rule for 4-space indentation in `AGENTS.md` overrides a 2-space indentation rule in `user_rules.md`.

```markdown
# In AGENTS.md (highest priority)
- Use 4-space indentation

# In user_rules.md (lower priority)
- Use 2-space indentation

# Result: 4-space indentation (AGENTS.md wins)
```

--------------------------------

### Troubleshoot MCP Server Manual Command Execution

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

Manually execute the MCP server command using `npx` to test its functionality and identify potential issues with package installation or command arguments. The `-y` flag bypasses the confirmation prompt.

```shell
npx -y @modelcontextprotocol/server-postgres "postgresql://..."
```

--------------------------------

### Plan Mode Refactoring Request Example

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/refactoring

Demonstrates how to initiate a refactoring request using Verdent AI's Plan Mode. This mode allows for a detailed review of the proposed changes before execution, ensuring clarity and control over the refactoring process.

```plaintext
In Plan Mode: Refactor authentication logic to use a centralized authentication utility
```

--------------------------------

### Troubleshoot MCP Server JSON Validation

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

Validate the JSON syntax of the .mcp.json configuration file using the `jq` command-line JSON processor. This is crucial for ensuring the MCP server starts correctly.

```shell
cat .mcp.json | jq .
```

--------------------------------

### Configure Project-Specific MCP PostgreSQL Servers for Microservices

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

This JSON configuration sets up MCP servers for specific microservices, such as user and order databases. It directly embeds the PostgreSQL connection URIs within the configuration. This approach is suitable for project-specific setups where environment variables might not be as granularly managed.

```json
{
  "mcpServers": {
    "users-db": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5432/users"
      ]
    },
    "orders-db": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://localhost:5433/orders"
      ]
    }
  }
}
```

--------------------------------

### Generate UserProfile Component (React)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Creates a React UserProfile component based on a natural language description. It specifies the structure (avatar, name, email) and styling (circular avatar). Assumes a React project setup.

```text
Create a UserProfile component that shows the user's avatar image, name as a heading, and email below it. Make the avatar circular.
```

--------------------------------

### Customize Verdent Shortcuts via keybindings.json (Windows/Linux)

Source: https://docs.verdent.ai/verdent-for-vscode/configuration/settings

This JSON snippet illustrates how to customize Verdent keyboard shortcuts using the keybindings.json file on Windows and Linux systems. It enables users to map specific key combinations to Verdent commands for enhanced efficiency.

```json
{
  "key": "ctrl+shift+v",
  "command": "verdent.addToChat"
}
```

--------------------------------

### Explain Application Architecture (ASCII)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/understanding-code

Verdent explains application architecture through text descriptions, component relationships, and data flow. It can generate ASCII art diagrams to represent component interactions.

```ascii
Frontend (React)
    ↓
API Layer (Express)
    ↓
Service Layer (Business Logic)
    ↓
Database Layer (PostgreSQL)
```

--------------------------------

### Ensure Cross-Platform Compatibility (Bash)

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/common-issues

This section illustrates how to manage bash commands that may differ between operating systems like Windows and Unix. It suggests using cross-platform tools or implementing conditional execution.

```bash
# Use cross-platform tools when possible
bash("npm run build")  # Works everywhere

# Or conditional execution
bash("if [[ \"$OSTYPE\" == \"linux-gnu\"* ]]; then ...; fi")
```

--------------------------------

### Incremental Refinement: Improving Rule Specificity

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Illustrates how to refine ambiguous rules by adding specific, actionable directives, moving from a general guideline to concrete implementation steps. This improves clarity and consistency in agent behavior.

```markdown
Before:
- Use appropriate error handling

After:
- Wrap async operations in try/catch blocks
- Return error objects with message and code fields
- Log errors with context (function name, input parameters)
```

--------------------------------

### Verify Linux System Requirements (glibc and GLIBCXX)

Source: https://docs.verdent.ai/verdent-for-vscode/getting-started/system-requirements

These commands verify the glibc and GLIBCXX library versions on a Linux system. Verdent AI requires glibc version 2.28 or later and GLIBCXX version 3.4.25 or later. Ensure your system meets these minimums for proper operation.

```bash
# Check glibc version (need 2.28 or later)
ldd --version

# Check GLIBCXX version (need 3.4.25 or later)
strings /usr/lib/x86_64-linux-gnu/libstdc++.so.6 | grep GLIBCXX
```

--------------------------------

### Create todos.md for Task Planning

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Utilize a todos.md file to outline complex, multi-step tasks. This provides a clear roadmap, facilitates collaboration, and ensures work persistence across sessions.

```markdown
Create a todos.md file with these tasks:
1. Refactor authentication to use JWT tokens
2. Update all controllers to use new auth middleware
3. Add tests for authentication flow
4. Update API documentation
```

--------------------------------

### Clarifying Database Constraints (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Explains how to provide unstated constraints to the AI after initial implementation, such as modifying database schema expectations. This ensures the AI works within existing architectural limitations.

```text
Good approach, but don't modify the database schema - work within the existing User table structure
```

--------------------------------

### Refactor Authentication to JWT - Node.js

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Guides refactoring of authentication middleware to use JWT tokens instead of session cookies. It emphasizes preserving authorization logic, updating token handling, and ensuring backward compatibility with existing routes.

```javascript
Refactor the authentication middleware in middleware/auth.js to use JWT tokens instead of session cookies. Keep the same authorization logic, but:
- Replace session validation with JWT verification
- Store tokens in httpOnly cookies
- Maintain the existing user object structure that routes expect
- Update only the authentication mechanism, don't change authorization rules
- Ensure all existing routes continue to work without modification
```

--------------------------------

### Refine API Authentication Prompt (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Demonstrates refining a generic prompt for API authentication into a more specific one. This method is useful when an initial broad request yields a too-general response, and specific details are needed for implementation.

```text
Initial prompt:
Add authentication to the API

Verdent's response might be generic. Refine:
Use JWT tokens stored in httpOnly cookies, implement refresh token rotation, and follow the authentication pattern from our existing UserController
```

--------------------------------

### Using Priority Markers for Non-Negotiable Rules

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Shows how to use keywords like 'CRITICAL:' and 'REQUIRED:' to denote rules that must be strictly followed, differentiating them from preferred practices. This helps in establishing clear security and functional mandates.

```markdown
## Security Rules
- **CRITICAL:** Never log passwords, API keys, or tokens
- **REQUIRED:** All user inputs must be validated and sanitized
- Preferred: Use parameterized queries for database operations
```

--------------------------------

### Implement Pagination for Blog Posts (API Integration)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Implements pagination for a blog post list, fetching data from an API and updating URL query parameters. Requires frontend logic to handle button clicks, state updates, and API calls, as well as backend support for paginated API endpoints.

```text
Implement pagination for the blog posts list with 10 posts per page. Add Previous/Next buttons and page number indicators. Update the URL query params (?page=2) and fetch data from /api/posts?page=X&limit=10.
```

--------------------------------

### Create and Push Annotated Git Tags for Releases

Source: https://docs.verdent.ai/verdent-for-vscode/common-workflows/version-control

This section covers creating annotated Git tags for releases, which include metadata like release notes. It also shows how to push all local tags to the remote repository. Annotated tags are recommended for releases as they store more information than lightweight tags.

```bash
git tag -a v1.2.0 -m "Release 1.2.0

New Features:
- User notification system
- Email integration
- Real-time WebSocket support

Bug Fixes:
- Fixed authentication timeout issue
- Resolved cart calculation bug"
```

```bash
git push origin --tags
```

--------------------------------

### Collect Diagnostic Information (Bash)

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/common-issues

This snippet provides bash commands to gather diagnostic information for troubleshooting Verdent AI issues. It includes commands for checking the VS Code version, system information, and locating Verdent logs.

```bash
# VS Code version
bash("code --version")

# System info
bash("uname -a")  # Unix
bash("systeminfo")  # Windows

# Verdent logs location
# Check VS Code Output panel → Verdent
```

--------------------------------

### Refactoring Authentication System with Plan Mode (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Describes using 'Plan Mode' for major architectural changes, such as refactoring an authentication system to support OAuth providers. This involves reviewing the AI's proposed plan before execution, allowing for iteration on the approach.

```text
Switch to Plan Mode
Show me how you would refactor the authentication system to support OAuth providers
```

--------------------------------

### Explorer Agent for Comprehensive Code Search

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/refactoring

An example of how to instruct Verdent AI to use the Explorer agent for thorough code searches. This ensures that all instances of a particular code pattern or functionality are identified and refactored consistently across the project.

```plaintext
Use the Explorer agent to find all places where we manually validate email addresses, then refactor them to use a centralized validation utility
```

--------------------------------

### Enable Deep Reasoning with Think Hard Mode

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Enable extended reasoning for sophisticated challenges by prefixing your prompt with 'Think:'. This activates deeper analysis for complex problems, thorough evaluation of alternatives and edge cases, and produces more robust solutions where correctness is paramount, though it may result in slower responses.

```text
Think: Design the optimal database schema for a multi-tenant SaaS application
```

--------------------------------

### Creating Custom Subagents in Verdent AI

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/faqs

Defines how to create custom subagents by providing a markdown file in the `~/.verdent/subagents/` directory. This includes specifying the subagent's name, description, and system prompt for behavior definition.

```markdown
---
name: your-subagent
description: Purpose description
---
# System Prompt
[Behavior definition and expertise]
```

--------------------------------

### Customize Verdent Shortcuts via keybindings.json (macOS)

Source: https://docs.verdent.ai/verdent-for-vscode/configuration/settings

This JSON snippet demonstrates how to customize Verdent keyboard shortcuts using the keybindings.json file on macOS. It allows users to define custom key combinations for Verdent commands, providing a more personalized workflow.

```json
{
  "key": "cmd+shift+v",
  "command": "verdent.addToChat"
}
```

--------------------------------

### Time-Conscious Plan Structure (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Defines a plan structure focused on time management, including time estimates for each step, total project duration, identification of parallel tasks, and highlighting the critical path. Tasks are sized in 30-minute increments.

```markdown
---
name: Time-Conscious
version: 1.0.0
last_updated: 2025-11-26
---

## Plan Structure
- Time estimates for each step
- Total project duration estimate
- Parallel tasks identified
- Critical path highlighted

## Level of Detail
- Tasks sized to 30-minute increments
- Dependencies clearly marked
- Blocking operations identified

## Format
- Include time estimates inline
- Mark parallel tasks
- Highlight critical path with bold

**Application:**    Plans will include:

* Each step with time estimate: "Create authentication middleware (45 minutes)"
* Total duration: "Estimated total: 6 hours"
* Parallel tasks marked: "Can be done in parallel with step 3"
* Critical path bolded to show blocking operations
```

--------------------------------

### Incremental Feature Building with Follow-Up Prompts (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Shows a sequential approach to building features by issuing follow-up prompts within the same session. This allows for incremental development, adding complexity and features step-by-step based on previous outputs.

```text
Initial: "Create a UserProfile component"
Follow-up: "Add an avatar upload feature with image preview"
Follow-up: "Add validation - max 5MB, only jpg/png formats"
Follow-up: "Show upload progress with a progress bar"
```

--------------------------------

### Requesting Explanations and Refining Choices (Verdent AI)

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Details a strategy for understanding the AI's reasoning behind specific implementation choices (e.g., Redux vs. Context API) and then providing corrective feedback based on that understanding. This is valuable for ensuring alignment with project standards.

```text
Why did you use Redux instead of Context API? Can you explain the trade-offs for this use case?

Actually, use Context API for consistency with the rest of our application
```

--------------------------------

### Implement Progressive Adoption of Code Standards

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

This Markdown illustrates a phased approach to adopting code standards. Phase 1 focuses on basic code standards like TypeScript strict mode and pre-commit testing. Phase 2 introduces specialized subagents for code reviews, and Phase 3 integrates MCP servers for database access.

```markdown
## Code Standards
- Use TypeScript strict mode
- Run tests before commit
```

```markdown
## Code Review
- Run @security-reviewer before PR
```

```markdown
## Database Access
- Use MCP postgres-staging for queries
```

--------------------------------

### Explain Application Architecture (Mermaid)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/understanding-code

Verdent explains application architecture and can generate Mermaid code for rendering diagrams, illustrating component relationships and data flow. This allows for visual representation of the system's structure.

```mermaid
graph TD
    A[React Frontend] --> B[API Gateway]
    B --> C[Auth Service]
    B --> D[User Service]
    C --> E[Database]
    D --> E
```

--------------------------------

### Write Unit Tests for UserService - Node.js

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Outlines requirements for writing comprehensive unit tests for a UserService class. It details specific scenarios to cover, including data validation, password hashing, user lookups, and error handling, specifying the use of Jest and existing test patterns.

```javascript
Write comprehensive unit tests for the UserService class in services/UserService.js. Cover:
- User creation with valid and invalid data
- Email validation edge cases (empty, malformed, duplicate)
- Password hashing verification
- User lookup by ID and email
- Error handling for database failures
Use Jest and follow the testing patterns in existing service tests
```

--------------------------------

### Custom Subagent File Structure (Markdown/YAML)

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/subagent-management

Defines the structure for custom subagent configuration files. It includes YAML frontmatter for metadata, a system prompt for behavior definition, invocation policy, and usage guidelines. This format allows for specialized agent creation tailored to specific project needs.

```markdown
---
name: subagent-name
description: Brief description of specialization
---
# System Prompt

[Behavior definition, personality, interpretation style]

Invocation policy (strict): Only run if explicitly requested.

When to use:
- Specific scenario 1
- Specific scenario 2

When NOT to use:
- Avoid scenario 1
- Avoid scenario 2

```

--------------------------------

### High-Level Strategic Plan Structure (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Outlines a strategic planning approach focusing on a brief overview, major phases, key decisions, and success criteria. It avoids implementation specifics, emphasizing the 'why' over the 'how', and uses bullet points for flexibility.

```markdown
---
name: High-Level Strategic
version: 1.0.0
last_updated: 2025-11-26
---

## Plan Structure
- Brief overview (1 paragraph)
- Major phases only (3-5 high-level steps)
- Key decisions and trade-offs
- Success criteria

## Level of Detail
- High-level phases (1-2 hours each)
- Avoid implementation specifics
- Focus on approach and strategy

## Format
- Bullet points for flexibility
- Minimal code examples
- Emphasize "why" over "how"

**Application:**    Plans will be high-level, focusing on:

* Strategic approach in 3-5 major phases
* "Why" explanations over implementation details
* Decision points and trade-offs
* Success criteria without specific implementation
```

--------------------------------

### Create POST /api/users/register Endpoint (Node.js/Express)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Creates a backend API endpoint for user registration. Includes validation for email format, password strength, and checks for duplicate emails before database insertion. Assumes a Node.js/Express environment with database integration.

```text
Create a POST /api/users/register endpoint that validates email format, password strength (min 8 chars, uppercase, number, special char), and checks for duplicate emails before creating the user in the database.
```

--------------------------------

### Specific Glob Pattern Usage

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/tool-reference

Illustrates the use of specific glob patterns for efficient file searching, contrasting narrow scope searches with overly broad ones. Emphasizes limiting results.

```bash
# Good: Specific scope
glob("src/components/**/*.tsx", max_results=50)

# Less efficient: Too broad
glob("**/*")  # Returns thousands of results
```

--------------------------------

### Project Rules Definition (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/extensibility

Defines project-wide rules and standards in a Markdown file. These rules can cover security, compliance, and operational guidelines.

```markdown
## Security Standards
- All API endpoints must validate inputs
- Never log PII or credentials
- Encrypt sensitive data at rest and in transit

## Compliance
- Run @compliance-auditor before all PRs
- Document data retention policies in code comments
- Include audit trails for data access
```

--------------------------------

### Detailed Technical Plan Structure (Markdown)

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

Defines a comprehensive plan structure for detailed technical planning, including an executive summary, prerequisites, step-by-step implementation, testing, and rollback procedures. It emphasizes breaking down tasks into 20-30 minute increments with specific file paths and function signatures.

```markdown
---
name: Detailed Technical
version: 1.0.0
last_updated: 2025-11-26
---

## Plan Structure
- Executive summary (2-3 sentences)
- Prerequisites and dependencies
- Numbered implementation steps
- Testing and verification strategy
- Rollback procedures

## Level of Detail
- Break into 20-30 minute tasks
- Specific file paths for all modifications
- Function signatures for new code
- Database schema changes with migration steps

## Format
- Numbered lists for sequence
- Code blocks for complex logic
- Diagrams for architecture changes (describe verbally)

**Application:**    Plans will include:

* Executive summary at the top
* 20-30 minute task breakdowns
* Specific file paths like `src/components/Auth/Login.tsx`
* Function signatures like `async function authenticateUser(credentials: UserCredentials): Promise<AuthResult>`
* Testing and rollback procedures
```

--------------------------------

### Execute Platform-Specific Bash Commands

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/limitations

This snippet illustrates how to use conditional logic within bash commands to handle differences between operating systems (e.g., Linux/macOS vs. Windows). It leverages the 'bash' function and standard shell constructs for cross-platform compatibility.

```bash
bash("npm run build")
bash("if [[ \"$OSTYPE\" == \"linux-gnu\"* ]]; then make; else nmake; fi")
```

--------------------------------

### Configure MCP PostgreSQL Servers for Development, Staging, and Production

Source: https://docs.verdent.ai/verdent-for-vscode/advanced-features/integrations

This JSON configuration defines MCP servers for PostgreSQL databases across different environments (development, staging, production). It specifies the command to run and arguments, including environment variables for database connection URLs. Best practice is to use environment variables for secure credential management.

```json
{
  "mcpServers": {
    "postgres-dev": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${DEV_DATABASE_URL}"
      ]
    },
    "postgres-staging": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${STAGING_DATABASE_URL}"
      ]
    },
    "postgres-prod": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "${PROD_DATABASE_URL}"
      ]
    }
  }
}
```

--------------------------------

### Handle Large Files with Line Ranges and Grep

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/limitations

This snippet shows how to manage large files by reading specific line ranges or using 'grep_content' to find relevant sections before reading. It utilizes the 'file_read' and 'grep_content' functions to avoid overwhelming the context window.

```python
file_read("large.log", start_line=1000, max_lines=100)
grep_content("ERROR", glob="large.log")
```

--------------------------------

### Project Rules Configuration (AGENTS.md)

Source: https://docs.verdent.ai/verdent-for-vscode/configuration/tuning

Defines project-specific coding standards, testing requirements, and architectural patterns. This file should be committed to version control.

```markdown
# Project Rules

## Code Standards
- Use TypeScript strict mode
- Generate unit tests for all new functions
- Follow MVC pattern

## Testing
- All endpoints require input validation
- Run tests before committing
```

--------------------------------

### Reference Images by Path in Verdent

Source: https://docs.verdent.ai/verdent-for-vscode/common-workflows/images

This snippet shows how to reference images using absolute and relative file paths for analysis in Verdent. It supports common image formats like PNG, JPG, and WebP. Ensure the paths are correct for Verdent to access the images.

```bash
# Analyze this screenshot: /path/to/screenshot.png

```

```bash
# Absolute Path examples:
/home/user/screenshots/error.png
/Users/john/Desktop/mockups/design.png

```

```bash
# Relative Path (Project Root) examples:
./screenshots/error.png
./mockups/design.png

```

```bash
# Relative Path (Current Directory) examples:
../images/diagram.png
../../assets/logo.png

```

--------------------------------

### Markdown for Plan Rules Configuration

Source: https://docs.verdent.ai/verdent-for-vscode/agents-rules/rule-systems

This markdown snippet defines the structure and content for Plan Rules, specifying sections like Plan Structure, Level of Detail, and Format. It uses markdown formatting to delineate different rule categories and their respective content.

```markdown
---
name: Plan Rules
version: 1.0.0
last_updated: 2025-11-26
---

## Plan Structure
- Start with brief summary (2-3 sentences)
- Include estimated time for each major step
- List prerequisites before implementation steps
- Identify potential risks

## Level of Detail
- Break tasks into subtasks of 15-30 minutes
- Include specific file paths for modifications
- List functions/components to create/modify

## Format
- Use numbered lists for sequential steps
- Use bullet points for options
- Include code snippets for complex changes
```

--------------------------------

### VS Code Workspace Settings

Source: https://docs.verdent.ai/verdent-for-vscode/configuration/tuning

Configures extension settings at the workspace level. This file should be located at .vscode/settings.json in the workspace root.

```json
{
  "verdent.enableCheckpoints": true
}
```

--------------------------------

### Custom Subagent Definition (Markdown with YAML)

Source: https://docs.verdent.ai/verdent-for-vscode/configuration/settings

Defines a custom subagent's name, description, system prompt, and invocation policy. The system prompt establishes the subagent's persona and guidelines, while the invocation policy dictates when it should be activated. This format is used for creating new subagents.

```markdown
---
name: security-reviewer
description: Security-focused code review specialist
---
# System Prompt

You are a security-focused code reviewer. When analyzing code:
- Prioritize security vulnerabilities (SQL injection, XSS, auth flaws)
- Use skeptical, critical tone - assume code is vulnerable until proven otherwise
- Provide specific remediation steps with code examples
- Reference OWASP Top 10 and security best practices
- Never approve code with unresolved security issues

Invocation policy (strict): Only run security-reviewer if user explicitly requests it.

When to use the security-reviewer agent:
- User requests security review of authentication/authorization logic
- User asks to audit code for vulnerabilities
- User needs security assessment before deployment

When NOT to use:
- General code review without security focus
- Opening or reading files without analysis

```

--------------------------------

### Create Footer Component (Frontend)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Generates a footer component for a website, including copyright information and links. Verdent adapts the implementation to match existing project conventions.

```text
Create a footer component with copyright and links
```

--------------------------------

### Execute Bash Commands for Binary File Operations

Source: https://docs.verdent.ai/verdent-for-vscode/help-support/limitations

This snippet demonstrates how to use bash commands within Verdent AI to perform operations on binary files, such as image conversion or PDF text extraction. It requires the 'bash' function and external command-line tools like 'convert' or 'pdftotext'.

```bash
bash("convert input.png -resize 50% output.png")
bash("pdftotext document.pdf output.txt")
```

--------------------------------

### Add Login Form (React)

Source: https://docs.verdent.ai/verdent-for-vscode/task-based-guides/writing-code

Adds a login form with email and password fields to an existing authentication page. Assumes a React context where an authentication page exists.

```text
Add a login form with email and password fields to the authentication page
```

--------------------------------

### Reference Files and Components with @-Mentions

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Use the @-mention syntax to explicitly reference specific files, components, or subagents. This ensures Verdent has the exact context by including particular files, preventing ambiguity in large codebases and guaranteeing all relevant code is visible for accurate refactoring.

```text
@auth.js @UserController.js Refactor authentication to use the same validation pattern
```

--------------------------------

### Execute Large Changes in Plan Mode

Source: https://docs.verdent.ai/verdent-for-vscode/best-practices/prompts

Switch to Plan Mode before execution for large or complex changes. This allows you to review Verdent's complete approach before any files are modified, preventing costly mistakes and enabling iteration on the plan or constraints before execution begins.

```text
Switch to Plan Mode
Refactor the entire API layer to use TypeScript with strict type checking
```
Tokens:
Raw