Feature Request - Codebase Indexing for AWS Kiro IDE

[jamesjhonatan123]

Feature Description

Hello AWS Kiro Team,
I've been using AWS Kiro and I'm impressed with the IDE's capabilities. However, I'd like to suggest an important feature that would significantly enhance the development experience: comprehensive codebase indexing.
Currently, Kiro doesn't provide the same level of codebase indexing that other AI-powered IDEs like Cursor offer. This feature would enable:

Better code understanding: The AI assistant could have full context of the entire project structure, functions, classes, and dependencies
More accurate suggestions: With indexed knowledge of the codebase, the AI could provide more relevant and contextual code completions and refactoring suggestions
Improved navigation: Jump to definitions, find all references, and explore code relationships across the entire project
Enhanced debugging: Better understanding of code flow and dependencies when troubleshooting issues

This indexing capability would make Kiro significantly more competitive with other AI-powered development tools and would greatly improve productivity for developers working on large codebases.
I believe this feature would be a valuable addition to Kiro's roadmap and would help establish it as a leading AI-powered IDE in the market.
Thank you for considering this suggestion, and I look forward to seeing Kiro's continued evolution.
Best regards,
Jonatas

Use Case

1. Cross-File Code Completion and Context Awareness

Scenario: Developer is working on a React component and starts typing a function name from another file
Current State: Kiro may not recognize functions/classes from other files in the project
With Indexing: Kiro would provide intelligent autocomplete suggestions for all functions, classes, and variables across the entire codebase, including proper import statements

2. Refactoring Large Codebases

Scenario: Developer needs to rename a function that's used across multiple files in a large enterprise application
Current State: Manual search and replace across files, prone to errors
With Indexing: Kiro could safely rename the function and automatically update all references, imports, and dependencies throughout the project

3. Understanding Legacy Code

Scenario: Developer joins a team and needs to understand how a complex feature works across multiple modules
Current State: Developer manually traces through files to understand code flow
With Indexing: Kiro could explain the entire feature flow, show relationships between components, and generate documentation based on the indexed codebase

4. API Integration Assistance

Scenario: Developer is integrating with an internal API and needs to understand existing usage patterns
Current State: Developer searches through files manually or asks team members
With Indexing: Kiro could show all existing API calls, common patterns, error handling approaches, and suggest consistent implementation based on the codebase

5. Dependency Analysis and Migration

Scenario: Team needs to upgrade a major library version and understand impact across the application
Current State: Manual search for library usage and potential breaking changes
With Indexing: Kiro could identify all library usage, highlight potential conflicts, and suggest migration strategies based on the current codebase structure

6. Code Review Enhancement

Scenario: Developer submits a pull request that might affect other parts of the application
Current State: Reviewers manually check for potential impacts
With Indexing: Kiro could automatically identify affected components, suggest additional test cases, and flag potential breaking changes

7. Test Generation

Scenario: Developer needs to write comprehensive tests for a new feature
Current State: Developer manually identifies test cases and mocks
With Indexing: Kiro could analyze the codebase to generate relevant test cases, identify dependencies to mock, and suggest edge cases based on existing patterns

8. Performance Optimization

Scenario: Application performance issues need to be identified and resolved
Current State: Developer profiles the application and manually searches for performance bottlenecks
With Indexing: Kiro could identify performance anti-patterns, suggest optimizations based on the codebase structure, and recommend better architectural approaches

9. Documentation Generation

Scenario: Team needs to generate technical documentation for a complex system
Current State: Manual documentation writing, often incomplete or outdated
With Indexing: Kiro could generate comprehensive documentation including API references, architecture diagrams, and usage examples based on the actual codebase

10. Security Analysis

Scenario: Security audit requires identifying potential vulnerabilities across the application
Current State: Manual code review and security scanning tools
With Indexing: Kiro could identify security patterns, flag potential vulnerabilities, and suggest secure coding practices based on the existing codebase context

Additional Context

No response

[l4time]

Hey, it may or may not be a good idea: for instance Claude Code and Cline do not index your codebase but still perform extremely well.

I would like to suggest this article to everyone checking out this issue and the Kiro dev team:
https://cline.bot/blog/why-cline-doesnt-index-your-codebase-and-why-thats-a-good-thing

[schoemme]

Discord thread: https://discord.com/channels/1374034175430230016/1395227101224894485/1395227101224894485

[dguisinger]

I also would like codebase indexing.

I have found it often spends several tool requests trying to track down a particular file. Indexing could make this a single tool request to find.

Kiro also repeatedly is saying methods don't exist when the code already compiles fine, so then it inserts new versions of that method triggering duplicate method errors. If there was indexing down to the structural level of the files, Kiro could quickly locate methods and avoid duplicating them.