Workflows
- Onboard to a Codebase
- Cross-Repo Search
- AI Code Review
- Build Following Patterns
- Debug Across Files
- Multi-Agent Workflow
Scenario: You just joined a team and need to understand a large, unfamiliar project quickly.
Index the repository
Add the project repository in your CodeAlive dashboard and wait for indexing to complete.
Ask about architecture
Start with broad questions to understand the overall structure:
Copy
"What is the high-level architecture of this project?"
"What frameworks and libraries does this codebase use?"
"How is the code organized — what are the main modules?"
Find entry points
Narrow down to the most important files:
Copy
"Where is the main entry point of the application?"
"Show me the API route definitions"
"Where is the database schema defined?"
Start with
codebase_consultant for architecture-level questions, then switch to codebase_search when you need to find specific files.Scenario: You need to find how a shared library or API is used across multiple services in a microservices architecture.
Set up a workspace
In your CodeAlive dashboard, group related repositories into a workspace (e.g., “platform-services”).
Search across repositories
Use semantic search to find usage patterns across all repos:
Copy
"Search for usage of the UserService API across all repositories"
"Find all implementations of the PaymentGateway interface"
"Show me how the shared auth library is imported and used"
Use
get_data_sources first to see all available repositories and workspaces. Scope searches with workspace names for faster, more relevant results.Scenario: You need to review a pull request with full awareness of how the changes affect the broader codebase.
Understand the change context
Ask CodeAlive about the code being modified:
Copy
"Explain how the authentication middleware works in this project"
"What calls the handlePayment function and what depends on its return value?"
Check for pattern consistency
Verify the PR follows existing conventions:
Copy
"How do other API endpoints in this project handle validation?"
"Show me how similar services are structured in this codebase"
"What error handling pattern is used in the controller layer?"
Use
codebase_search to find related code quickly, then codebase_consultant to get a synthesized analysis of how the changes fit into the broader architecture.Scenario: You need to add a new API endpoint (or service, component, etc.) that matches the team’s existing conventions.
Find similar implementations
Search for existing patterns to follow:
Copy
"Show me an example API endpoint with full CRUD operations"
"How are controllers structured in this project?"
"Find a service that handles database transactions"
Analyze the pattern
Ask CodeAlive to extract the conventions:
Copy
"What is the standard structure for a new API endpoint in this project?"
"What middleware is applied to protected routes?"
"How are request validation and error responses handled?"
Generate matching code
Use the patterns as context for code generation:
Copy
"Create a new /api/orders endpoint following the same patterns as /api/products"
"Generate a service class for OrderService matching the structure of ProductService"
"Write tests for the OrderController using the same testing patterns as ProductController"
The search-then-generate flow produces much better results than asking for code from scratch. The AI sees your actual conventions, not generic best practices.
Scenario: You’re tracking down a bug that spans multiple files or services and need to trace the execution path.
Search for error context
Start from the error message or symptom:
Copy
"Search for where 'PaymentProcessingError' is thrown"
"Find all places where the order status is updated to 'failed'"
"Show me the error handling chain for payment webhooks"
Trace the data flow
Follow the execution path through the codebase:
Copy
"Trace the flow from when a payment webhook arrives to when the order status is updated"
"What functions call processPayment and what happens with the return value?"
"Show me the middleware chain that runs before the payment endpoint"
Use
codebase_search with specific error messages or function names for fast, targeted lookups. Switch to codebase_consultant when you need the AI to reason about execution flow.Scenario: You want to research in one AI agent and implement in another — with both sharing the same codebase context.
Research in your preferred agent
Use CodeAlive in Cursor, VS Code, or any connected agent to explore:
Copy
"How does the notification system work?"
"What would need to change to add email notifications?"
"Show me the existing notification channels and their implementations"
Switch agents for implementation
Open Claude Code (or any other agent) — CodeAlive provides the same context:Both agents query the same indexed codebase, so your research carries over naturally.
Copy
"Search for the NotificationService implementation"
"Create an EmailNotificationChannel following the pattern of SlackNotificationChannel"
CodeAlive acts as a shared knowledge layer. Index once, query from any agent. This is especially useful when different agents have different strengths — use Cursor for exploration and Claude Code for implementation, for example.