Hardware engineers spend up to 30% of their time navigating code instead of writing it. I used Kiro to build a system that indexes, visualizes, and even AI-assists Verilog development — all inside VS Code. Here’s how I transformed chaotic hardware projects into structured, efficient workflows with AI-powered planning and coding.
Why Verilog Needs Better Tools
Verilog projects are notoriously messy. Modules are scattered across dozens of files, signal flows are invisible, and documentation is minimal. AI tools either ignore hardware languages or offer irrelevant suggestions. I wanted to change that.
With Kiro, I built VeriGraph, an AI-enhanced, graph-aware Verilog code intelligence system that helps engineers navigate designs, identify bugs, and write production-ready code — all while keeping performance, monitoring, and debugging in mind.
🚀 Phase 0 – Spec Mode: Thinking Before Coding
When I opened Kiro and asked it to “Help me build a tool that indexes Verilog codebases,” I expected it to generate code immediately. Instead, it asked:
“Before we code — let’s structure this. Would you like me to generate
design.md,requirements.md, andtasks.mdto get started?”
That pause changed everything. Kiro helped me plan like a senior engineer, giving me structured files to guide development.
Files Kiro Generated:
✅ design.md – The “Why” and “What”
Defines architecture, user experience, and vision.
✅ requirements.md – The “Must-Haves”
Outlines functional needs, constraints, and performance goals.
✅ tasks.md – The “How” and “When”
Breaks down the project into ordered steps with dependencies and effort estimates.
This approach transformed how I think about building software — from guesswork to clarity.
💡 Phase 4 – Task-by-Task Development with Kiro as Copilot
For each task, I would:
- Click the task → “Implement this with Kiro.”
- Review the generated code → test → refine → commit.
- Move to the next task.
Example prompt:
“Kiro, implement task #2: Build CacheManager with LRU + disk fallback.”
It felt like pair programming with someone who already read the spec. Kiro even anticipated my needs — suggesting unused signal detection based on the design goals, not just following instructions.
✅ Key Features Built with Kiro
📦 Multi-Level Caching
Prompt: Design a CacheManager with LRU memory cache + disk fallback.
Result: TypeScript interfaces, TTL support, and fallback logic integrated with symbol indexing.
🤖 AI Service Manager
Prompt: Create a service that abstracts multiple LLM providers with fallback and streaming support.
Result: Registry-driven architecture, context-building from parsed Verilog ASTs, and streaming handlers.
📊 Graph Builder for Signal Flow
Prompt: Parse Verilog ASTs to build a module graph tracking signal connections.
Result: Recursive walkers, path tracing, and JSON output for D3.js visualization.
🧠 VS Code Extension Enhancements
Prompt: Improve IntelliSense, go-to-definition, and find-references using symbol index and graph data.
Result: Hover info, status bar notifications, and error handling.
⚙ Performance Monitoring & Error Handling
Prompt: Add metrics tracking and centralized error reporting.
Result: Prometheus-style monitoring, error hooks, and health checks.
📂 The Spec That Guided Everything
# VeriGraph – Verilog Codebase Intelligence System
## Features
1. Multi-level caching (memory + disk) for fast symbol lookups
2. WebSocket server for real-time file change notifications
3. AI service manager supporting multiple LLM backends with streaming
4. Graph builder for module hierarchy + signal flow visualization
5. VS Code extension with IntelliSense, go-to-definition, and find-references
6. Performance monitoring + error handling
7. Search engine with fuzzy matching and pagination
❌ Where Kiro Needed My Help
While Kiro amazed me, it wasn’t perfect. Here’s where I had to step in:
✔ Didn’t understand generate blocks → I pasted examples → it learned
✔ AI context too long → I asked “how to trim?” → it suggested priority-based truncation
✔ VS Code API confusion → I said “use vscode.workspace, not fs” → it corrected itself
💡 Lesson: Kiro is a thinking partner, not a magic box. Feed it context, examples, and feedback — and it grows with you.
But the agent would keep waiting, then say:
“Command may have failed. Retrying (1/3)...”
And rerun the command multiple times — even though everything worked fine.
⚙ Common IDE Problems I Faced
❗ Irrelevant Autocomplete in Contextless Files
When editing the .env file, the autocomplete suggested JSON syntax — totally irrelevant.
Improvement suggestion: Make suggestions context-aware based on file type and syntax.
❗ Poor Quality Suggestions
Autocomplete suggestions were generic and unhelpful in many cases.
Improvement suggestion: Improve relevance and prioritize suggestions based on file semantics.
📈 Improvements Needed in the IDE
✅ Show Code Differences (Diff View) for AI-generated Code
Whenever the AI writes or modifies code, it should highlight changes in a diff view, similar to Git workflows. This makes reviewing changes easier.
✅ Context-aware Commit Messages in Git Integration
Automatically generate commit messages based on the intent and changes made during AI-assisted development.
✅ Prevent Hallucination by Integrating Web Search
AI sometimes hallucinates incorrect logic. Integrating web search and documentation can provide real examples and reduce errors.
✅ Better Context Handling Across Files
AI should reference definitions across files, even if they’re not open or immediately visible, ensuring suggestions are contextually aware.
✅ Memory-based Awareness of Known Issues
The AI should remember past functions and patterns to warn about edge cases or performance pitfalls.
✅ AI-powered Code Review Assistant
Integrate a system that flags bugs, inefficiencies, and style violations before code review, speeding up development cycles.
✅ Context Switching Across Projects and IDEs
Allow seamless context switching between multiple projects or IDEs while preserving state and workflow continuity.
✅ Customizable AI Behavior
Developers should be able to adjust AI verbosity, strictness, and aggressiveness based on project needs.
✅ Error Prediction and Testing Recommendations
Suggest tests and highlight potential runtime errors proactively.
✅ Security-aware Coding Suggestions
Flag unsafe code patterns like SQL injections or improper authentication in real-time.
✅ Learning from Developer Feedback
Allow users to approve or reject suggestions, improving AI personalization and relevance over time.
✅ Visualization Tools
Provide graphical views of function calls, data flow, and architecture to assist developers in understanding complex codebases better.
🚀 Final Thoughts
Kiro isn’t just another coding assistant — it’s a thinking partner that helps you plan, build, and ship better software. With VeriGraph, I learned how structured thinking combined with AI assistance can turn overwhelming projects into manageable, productive workflows.
This experience not only helped me build a smarter IDE but also taught me how to collaborate with AI — feeding it context, refining suggestions, and solving real-world problems together.
🙏 Thank You, Kiro Team
Kiro didn't just help me write code faster — it helped me think better. The spec-driven approach transformed chaotic ideas into structured, professional software architecture.
To other Kiro Hackathon participants: Don't skip the spec phase. That's where the real magic happens.
To the judges: VeriGraph represents the future of AI-assisted development — where planning, coding, and innovation happen seamlessly together.
Ready to revolutionize hardware development? Star the repo, try the extension, and let's build the future of Verilog tooling together!
Let’s build smarter, not harder.
.
💻 Try VeriGraph Yourself
🔗 GitHub Repository: https://github.com/Jackpkn/coding-engine
🚀
Built with ❤️ using Kiro — The AI IDE that thinks before it codes.
Top comments (0)