Common Use Cases

Practical, day‑one workflows you can run in the interactive terminal UI.

Droid excels at real-world development tasks. This guide shows practical workflows you can use immediately, with specific prompts that get great results.

Understanding a new codebase

Start with the big picture:

Analyze this codebase and explain the overall architecture.
What technologies and frameworks does this project use?
Where are the main entry points and how is testing set up?

Drill down into specifics:

Explain how user authentication flows through this system.
What are the main components in the frontend and how do they interact?
Show me where the API routes are defined and list the key handlers.

Navigate by domain:

Where does payment processing happen? Walk me through a typical payment flow.
Find all the database models and explain their relationships.
Show me the error handling patterns used throughout this codebase.

Droid leverages organizational knowledge and can read through your entire project structure to provide comprehensive explanations with relevant file references and architectural insights.

Fixing bugs and debugging

From error message to solution:

I'm seeing this error in production:
TypeError: Cannot read properties of undefined (reading 'title')
at src/components/PostCard.tsx:37:14

Help me reproduce locally and fix it. Explain the root cause first.

Using logs for debugging:

Here are the server logs from the last hour showing 500 errors.
Find the failing code path and propose a fix with proper error handling.

Systematic debugging:

Users report that file uploads fail randomly with "Network timeout" errors.
The upload logic is in src/upload/handler.ts.
Add logging to diagnose the issue and implement retry logic.

Droid will analyze error patterns, create failing tests to reproduce issues, propose minimal fixes, and verify the solution works.

Building features

Enterprise workflow integration:

Implement the feature described in this Jira ticket: https://company.atlassian.net/browse/PROJ-123
Follow our security standards and include comprehensive error handling.

API development:

Add a PATCH /users/:id endpoint with email uniqueness validation.
Return 200 on success, 400 on invalid payload, 404 if user missing.
Update the OpenAPI spec and add integration tests.
Similar patterns exist in src/routes/users/get.ts.

Using Specification Mode: For complex features, use Specification Mode to automatically get planning before implementation. This ensures proper architecture and reduces iterations.

Working with tests

Test-driven development:

Write comprehensive tests for the user registration flow first.
Don't implement the actual registration logic yet.
Include tests for validation, duplicate emails, and password requirements.

Fixing failing tests:

Run tests and fix the first failing test.
Explain the root cause before making changes.
Show me the diff before applying any fixes.

Improving test coverage:

Identify untested critical paths in the payment processing module.
Propose specific test cases and implement them with proper mocks.

Code review

Local review workflow:

Use the /review command for guided code review workflows:

/review
# Choose from:
# - Review against a base branch (PR-style)
# - Review uncommitted changes
# - Review a specific commit
# - Custom review instructions

Direct review prompts:

Review my uncommitted changes and suggest improvements before I commit.

Review this PR for security vulnerabilities, performance issues, and code quality.
Focus on SQL injection risks and authentication bypass scenarios.

Review the last 3 commits for consistency with our coding standards.
Flag any deviations from the patterns in AGENTS.md.

Learn more about code review →

Safe refactoring

Structure improvements:

Refactor the authentication module into smaller files with no behavior change.
Keep the public API identical and run all tests after each change.

Dependency updates:

Replace the deprecated bcrypt library with bcryptjs project-wide.
Update all imports and ensure compatibility across the codebase.
Show a summary of all files changed.

Code quality:

Extract the shared date utility functions into a separate module.
Update imports across the repository and run tests to confirm identical behavior.

Documentation and communication

API documentation:

Generate comprehensive OpenAPI specification for the payments service.
Include request/response examples and error codes.
Create a TypeScript SDK based on the spec.

Code explanations:

Explain the relationship between the AutoScroller and ViewUpdater classes using a diagram.
Document the data flow and key methods for new team members.

Release management:

Summarize all changes in this branch and draft a pull request description.
Include breaking changes and migration notes for API consumers.

Enterprise integration

Team tool integration: If you’ve integrated platforms through Factory’s dashboard, droid can automatically read context when you paste links to specific tickets or documents:

Read this Jira ticket and implement the feature: https://company.atlassian.net/browse/PROJ-123
Include all the acceptance criteria and follow our security standards.

Use the requirements from this Notion spec to implement the user preferences API: https://notion.so/team/user-prefs-spec
Follow the data structure and validation rules outlined in the document.

Security-focused development:

Add file upload functionality with proper validation to prevent directory traversal attacks.
Follow the security patterns used in our existing document upload feature.
Include rate limiting and file type validation.

Compliance considerations:

Review this authentication implementation for GDPR compliance.
Ensure proper data encryption and user consent handling.
Add audit logging for all user data access.

Getting the most value

Be specific and direct: Instead of “fix the login bug,” try “fix the authentication timeout where users get logged out after 5 minutes instead of the configured 30 minutes.”

Provide verification steps: Tell droid how to confirm success—run specific tests, check that services start cleanly, or verify UI behavior.

Use organizational knowledge: Reference team conventions, existing patterns, and established practices. Droid learns from your codebase and can help maintain consistency.

Leverage the review workflow: Always review proposed changes before approval. The transparent diff view helps you understand modifications and provide feedback for better future results.

Next steps

Ready to try these workflows? Head to the Quickstart to get droid running, or dive into Specification Mode for complex feature development. For more communication tips, see How to Talk to a Droid to learn proven prompting patterns that get better results. For more communication tips, see How to Talk to a Droid to learn proven prompting patterns that get better results.