Let's be honest. We've all been there right:
- Forgot to split changes into separate commits, ending up with a "mega-commit" that fixed a bug, added a feature, and updated the README all at once.
- Write vague, useless commit messages like "update files" or "fix stuff" that meant nothing to my future self or my team.
- Waste time staging and committing manually, breaking my flow state and turning version history into a chore rather than a helpful log.
It's a bad habit I wanted to break, so I decided to build Gitcom—an AI-powered commit assistant extension for Kiro. The twist? I used Kiro itself as my pair programmer, design partner, and project manager throughout the entire journey.
Here’s the story of how I built it and how Kiro’s unique features transformed my development process.
How Kiro Helped Me Build Gitcom
One of the best parts of this project was learning to build with Kiro as my co-pilot. I didn’t just code—I collaborated with Kiro’s tools and agents at every stage:
🔗 Automate Tasks with Agent Hooks
I used agent hooks to log my conversations with Kiro. This provided me with a timeline of my decisions, the ideas we discussed, and the project's evolution.
💬 Vibe with the Kiro Chat
Kiro’s chat-first approach was like brainstorming with a teammate. I started by exploring the idea of a commit assistant, discussing:
- Technologies I might need
- Dependencies like simple-git
- How to structure the extension
- This back-and-forth clarified my vision and guided the stack I chose.
📜 Tame Complexity with Spec-Driven Development
Here’s where Kiro really shone. It generated a spec for me called “intelligent-commit-generator”. The spec included:
- A design overview
- Requirements
- Tasks broken into steps
From there, I followed the tasks one by one. By the end, Kiro had essentially generated the entire project. It even suggested performance augmentation tasks later to refine the codebase.
My Self-Imposed Challenge: The Great TypeScript Migration
I wanted to test how well Kiro could adapt. So I challenged it to:
- Generate Gitcom in JavaScript
- Migrate Gitcom to TypeScript
Kiro handled both, but in different ways—sometimes by mapping JS to TS files automatically. Instead of relying fully on that, I decided to manually transform the JS project into TypeScript. Adding proper interfaces and enforcing strict types, I was forced to understand the purpose of every variable and function. This deep dive meant I owned the code and could now fix my own "update files" problem with a truly robust tool.
This challenge wasn’t just about the code—it helped me understand:
- How Kiro cleaned up files (sometimes leaving unused code)
- Where I needed to step in and refine things
- How to evaluate AI-generated code critically
The cleanup part was tricky—Kiro did attempt it when asked, but not always in the way I expected. Doing it manually became a great learning experience and gave me deeper insight into the project’s structure.
What I Built: Gitcom
At the end of this journey, I had a working Kiro extension: Gitcom – AI-Powered Commit Assistant.
✨ Key Features
- Git diff analysis with simple-git
- Interactive UI for reviewing and editing commits
- Batch commit operations for grouped staging
What's next for gitcom
- Continue developing Gitcom beyond the hackathon
- Add an interactive CLI that works seamlessly across platforms.
- Multiple commit styles: Conventional, Semantic, or Custom
- AI commit suggestions at 3 detail levels (concise/normal/verbose)
- GitHub/GitLab PR integration.
What I Learned
- Kiro is more than a tool: It’s like a co-developer that helps you explore, design, and build projects faster.
- Specs keep you focused: The spec-driven workflow broke down complexity into manageable tasks.
- AI isn’t perfect (yet): Code cleanups and updates left some unused code, which meant I had to step in. But this turned out to be a blessing—it pushed me to understand the generated project more deeply.
- Challenging the AI helps you grow: By asking Kiro to regenerate in different languages and comparing results, I learned more than I would have just by coding manually.
Final Thoughts
Building Gitcom was an amazing journey, not only because of what I built but because of how I built it—with Kiro by my side.
Kiro helped me brainstorm, plan, and even generate large parts of the project. But it also challenged me, especially when cleanup and refinement were needed. That’s where I grew the most as a developer.
Top comments (0)