Agent Guide Overview

Dropstone Agent is your AI-powered coding assistant built directly into Dropstone Desktop. Think of it as a knowledgeable team member who can help you write code, fix bugs, understand complex systems, and automate repetitive tasks - all through natural conversation.

What Can Dropstone Agent Do?

1. Understand Your Codebase

Dropstone Agent can analyze and understand projects of any size:

For Small Projects:

• Instantly grasp the entire project structure
• Understand relationships between files
• Track dependencies and imports

For Large Enterprise Codebases:

• Process 10,000+ files efficiently
• Build a searchable knowledge base
• Navigate complex architectures

In Practice:

You: "Show me how user authentication works in this project"
Agent: [Analyzes auth-related files, shows flow, explains security measures]

2. Write and Modify Code

The agent can create new code or modify existing code based on your descriptions:

Create New Features:

You: "Add a search feature to the product catalog with filters for price and category"
Agent: [Creates search UI, implements filter logic, adds API endpoints, writes tests]

Refactor Existing Code:

You: "This UserService class is too complex - break it into smaller, focused services"
Agent: [Analyzes code, proposes structure, creates new services, updates imports]

Fix Bugs:

You: "Users are seeing a blank screen after login"
Agent: [Investigates, finds the issue, proposes fix, implements solution, tests]

3. Learn and Improve Over Time

Unlike static tools, Dropstone Agent learns from each interaction:

Remembers Your Patterns:

• How you structure components
• Your naming conventions
• Preferred libraries and approaches
• Project-specific patterns

Adapts to Your Codebase:

• Learns your API patterns
• Understands your error handling style
• Follows your testing conventions
• Matches your code formatting

Example: After seeing you use certain patterns a few times, the agent automatically applies them to new code:

You: "Create a new API endpoint for deleting posts"
Agent: "I'll create it following the same pattern as your other endpoints,
       with try-catch error handling, validation middleware, and the
       standard response format you use throughout the project."

4. Autonomous Operation

The agent can work independently on tasks it's confident about:

High-Confidence Tasks: When the agent has successfully completed similar tasks before, it can:

• Read and analyze files automatically
• Make straightforward changes
• Run tests to verify changes
• Fix simple errors automatically

You Stay in Control:

• Configure what the agent can do autonomously
• Get notified of all actions
• Review changes before committing
• Adjust autonomy levels anytime

Example Autonomous Workflow:

You: "Add input validation to all the form components"

Agent operates autonomously:
1. Finds all form components (no approval needed - high confidence)
2. Analyzes existing validation patterns
3. Applies consistent validation to each form
4. Generates tests for validation logic
5. Runs tests to verify everything works
6. Reports back with summary

Total time: 3 minutes vs. 30+ minutes manually

5. Research and Problem Solving

When the agent encounters unfamiliar territory, it can research solutions:

Automatic Research:

• Searches Stack Overflow for solutions
• Finds relevant GitHub examples
• Reads official documentation
• Discovers best practices

Example:

You: "Implement rate limiting for our API"

Agent: "I'll research the best approaches for Express.js rate limiting..."
[Searches documentation and examples]
"I found three popular solutions. express-rate-limit is the most used
with 2.3k stars. It supports Redis for distributed systems. Let me show
you an implementation..."

6. Multi-Step Workflows

The agent can handle complex tasks that involve multiple steps:

Decomposition: Large tasks are automatically broken into manageable pieces:

You: "Migrate our authentication to use OAuth2"

Agent: "This is a complex task. I'll break it down:
1. Research OAuth2 implementation for our stack
2. Set up OAuth provider configuration
3. Create OAuth routes and middleware
4. Update login UI to support OAuth
5. Migrate existing users
6. Add tests
7. Update documentation

Let's start with step 1..."

Progress Tracking: You can see progress through each phase and continue conversations across sessions.

7. Quality Assurance

The agent helps maintain code quality:

Automatic Testing:

• Generates test cases
• Runs tests after changes
• Catches regressions early

Code Quality Analysis:

• Assesses complexity
• Detects code smells
• Suggests improvements

Impact Analysis:

• Shows what will be affected by changes
• Identifies potential breaking changes
• Recommends safer approaches

Example:

You: "Refactor the payment processing logic"

Agent: "Before I make changes, let me analyze the impact..."
[Analyzes dependencies]
"This payment processor is used in 12 places. Changes here could affect:
- Order completion flow
- Subscription renewals
- Refund processing

I recommend we:
1. Add comprehensive tests first
2. Make changes incrementally
3. Verify each step

Should I proceed?"

How It Works: The Agent Lifecycle

1. Understanding Your Request

When you type a message, the agent:

• Analyzes your intent (are you asking a question? requesting changes?)
• Identifies what files/code are relevant
• Determines if it needs more information
• Plans the approach

2. Gathering Context

The agent automatically:

• Reads relevant files
• Analyzes code structure
• Checks dependencies
• Reviews recent changes

You see: "🔍 Analyzing src/api/users.ts..."

3. Planning Execution

For complex tasks:

• Breaks down into steps
• Identifies dependencies
• Estimates effort
• Proposes approach

You see: A detailed plan with steps and estimated time

4. Taking Action

The agent executes the plan:

• Makes code changes
• Creates new files
• Runs commands
• Generates tests

You see: Real-time updates of what's happening

5. Verification

After changes:

• Syntax checking
• Type checking (TypeScript, etc.)
• Running tests
• Code quality analysis

You see: ✅ or ❌ for each verification step

6. Learning

After completion:

• Extracts patterns from success
• Updates knowledge base
• Improves confidence for similar tasks
• Adapts to your preferences

You don't see this: It happens automatically in the background

Working with the Agent

Natural Conversation

Talk to the agent like you would a team member:

Good:

"The user registration isn't working properly. When users submit the form
with a valid email, they get an error message saying the email is invalid."

Also Good:

"add email validation pls"

Both work! The agent adapts to your communication style.

Iterative Development

Build features through conversation:

You: Create a user profile component
Agent: [Creates basic component]

You: Add an avatar with upload functionality
Agent: [Adds avatar feature]

You: Add a loading state while uploading
Agent: [Adds loading state]

You: Let's also show upload progress
Agent: [Adds progress bar]

Using Context

Help the agent understand by adding context:

Reference Files:

@src/components/Button.tsx Create a similar Input component

Show Examples:

[Right-click on code → Add to Context]
"Create a similar function for handling post creation"

Provide URLs:

@https://stripe.com/docs/api Integrate Stripe checkout

Agent Capabilities Summary

Current Version: v2.0.11

What's Included

✅ Fully Functional:

• Core agent with conversation management
• 40+ language support with AST parsing
• 18 AGI components for autonomous operation
• Advanced memory system
• Self-learning capabilities
• Multi-mode operation (code, debug, architect, ask, orchestrator)
• Comprehensive tool suite (27 tools)
• MCP server integration
• Browser automation
• Git integration
• Terminal integration

🔬 Production Ready:

• Tested on enterprise-scale codebases (10,000+ files)
• Comprehensive error handling
• Performance monitoring
• Automatic recovery from failures
• Quality verification system

Designed For

Individual Developers:

• Solo projects and side projects
• Learning new technologies
• Code exploration and understanding
• Productivity boost for repetitive tasks

Development Teams:

• Shared workspace collaboration
• Consistent code patterns
• Knowledge sharing
• Code review assistance

Enterprise Projects:

• Large codebase navigation
• Legacy code modernization
• Technical debt reduction
• Compliance and quality standards

What Makes It Different

vs. Code Completion Tools (Copilot, etc.)

Code Completion:

• Suggests next lines
• Pattern matching
• No memory of project

Dropstone Agent:

• Understands entire project
• Can execute multi-file changes
• Learns your patterns
• Autonomous operation

vs. Chat-based Coding Assistants

Chat Assistants:

• Copy-paste code
• No direct file access
• Start from scratch each time

Dropstone Agent:

• Direct VS Code integration
• Modifies files directly
• Persistent memory
• Context-aware across sessions

vs. Traditional IDE Features

IDE Features:

• Require knowing what to look for
• Manual operation
• No understanding of intent

Dropstone Agent:

• Natural language requests
• Autonomous execution
• Intent understanding
• Proactive suggestions

Getting the Most Out of the Agent

1. Start Simple

Begin with straightforward requests:

• "Explain this function"
• "Add a TODO comment here"
• "Fix the indentation"

2. Build Trust Gradually

As you see the agent work well:

• Try more complex tasks
• Enable more auto-approvals
• Let it work more autonomously

3. Provide Feedback

The agent learns from feedback:

• Confirm when it does well
• Correct mistakes explicitly
• Explain your preferences

4. Use Specific Modes

Switch modes for specialized tasks:

• Debug mode for fixing bugs
• Architect mode for design
• Ask mode for questions

5. Review and Learn

Check what the agent does:

• Review code changes
• Read explanations
• Learn from implementations

Limitations and Considerations

What the Agent Can Do Well

✅ Understand and navigate codebases ✅ Generate boilerplate and common patterns ✅ Fix clear, reproducible bugs ✅ Refactor code with clear goals ✅ Generate tests from examples ✅ Research and apply best practices

What May Need Your Help

⚠️ Highly creative or novel solutions ⚠️ Domain-specific business logic ⚠️ Complex architectural decisions ⚠️ Subjective design choices ⚠️ Critical security implementations ⚠️ Performance optimization (needs profiling data)

Best Practice

Collaborative Approach:

• Use agent for heavy lifting
• Provide domain expertise
• Review critical changes
• Guide architectural decisions
• Let agent handle implementation details

Next Steps

Learn More:

• How to Use - Practical usage guide
• Self-Learning - How the agent improves over time
• AGI Capabilities - Deep dive into advanced features
• Best Practices - Expert tips and patterns

Get Started:

• Quick Start - Install and configure
• Settings Guide - Customize behavior
• Examples - Real-world use cases

Dropstone Agent is continuously learning and improving. The more you use it, the better it gets at helping you.