Weekend Vibe Coding 1: Building a GitHub Issue Processor with Kilo Code

Weekend Vibe Coding 1: Building a GitHub Issue Processor with Kilo Code

A few weekends ago, I found myself with that familiar itch - you know the one. The "I want to build something useful but don't want to spend 40 hours on it" itch. I've recently been fascinated by how AI can streamline development workflows, and I wanted to create something that would make my life easier when working with GitHub issues and AI coding assistants.

The result? A little terminal-based TypeScript tool I'm calling github-kilo that processes GitHub issues and generates comprehensive prompts for AI agents. This is the first in a series I'm calling "Weekend Vibe Coding" - where I'll share my experiences building real-world tools with AI assistance.

Vibe Coding vs. Vibe Engineering

Before we dive in, let me explain two terms I've been thinking about lately:

Vibe coding is what I did here - starting with a relatively blank slate and using AI to help build something new from scratch. It's playful, exploratory, and perfect for weekend projects. You're essentially treating AI as a toy to learn how to use it as a tool.

Vibe engineering, on the other hand, is where I think the real power lies for professional developers. It's when frontier AI models have enough context to truly understand large, complex codebases and help you navigate, modify, and extend them. This is how I believe developers will really use AI in their day-to-day work.

But you've got to crawl before you can walk. Vibe coding projects like this one help you develop the skills and intuition that will make vibe engineering possible later. It's like learning to ride a bike with training wheels before tackling a mountain trail.

The Problem I Wanted to Solve

Have you ever found yourself doing the same tedious task over and over again? For me, it was manually collecting GitHub issue details to create good prompts for AI coding assistants.

The workflow was always the same:

1. Find an issue in a GitHub repo

2. Copy the title and description

3. Copy all the relevant comments

4. Format everything into a coherent prompt

5. Ask the AI to help architect or code a solution

This process worked, but it was tedious. Each time I wanted to use an AI assistant to help with a GitHub issue, I had to do this copy-paste dance. Not the end of the world, but definitely ripe for automation.

Project Overview: github-kilo

What I wanted was simple: a terminal tool that would connect to GitHub, let me browse issues, and automatically generate well-structured prompts for AI agents with all the context they need.

github-kilo at work with previous repos and the ability to output one or all issues to a prompt

The core functionality includes:

• Connecting to GitHub via API

• Browsing and searching repository issues

• Selecting an issue (or processing all issues in bulk)

• Generating a comprehensive prompt with the issue's title, body, and all comments

• Either copying the prompt to my clipboard or saving it to a file

I chose TypeScript because, well, I like types. And because the GitHub API libraries for Node.js are solid. Plus, terminal UIs in JavaScript/TypeScript are surprisingly pleasant to build.

My "Vibe Coding" Approach with Kilo Code

This is where the "vibe coding" part comes in. Rather than mapping out every class and function beforehand, I started with a clear description of what I wanted and let Kilo Code help me flesh out the implementation.

I didn't want to overthink it. I wanted to play around, explore, and see what worked. The freedom of a weekend project is that it doesn't have to be perfect - it just has to be useful enough to solve your problem.

Here's how I approached it:

1. I wrote an initial prompt describing what I wanted to build

2. Reviewed what Kilo Code suggested, made tweaks to the approach

3. Refined the prompt with more details when needed

4. Tested the code, found issues, and asked for help fixing them

5. Added new features as they occurred to me

It was refreshing not to have to think about every implementation detail upfront. Instead, I could focus on what I wanted the tool to do and let Kilo Code handle much of the "how."

From Prompt to Working Code

My initial prompt was pretty straightforward:

Design and code a terminal-based application in TypeScript that helps users process GitHub issues and generate prompts for another AI agent to architect and code solutions for those issues.

This gave me a starting point, but it was too vague. So I used Kilo Code's enhance prompt feature which refined it with more specific requirements:

The application should have the following features and technical specifications:
* Interface: Terminal-based UI using libraries like inquirer
* Input: Let users specify a GitHub repository
* Issue Handling: List issues or search through them
* Authentication: Use GitHub API with personal access token
* AI Prompt Generation: Include issue title, body, comments
* Bulk Output Mode: Process all issues and save to files

I sent this first to Kilo Code's Architect Mode to design the solution. Kilo Code responded with a detailed architecture and implementation plan. The suggested approach was solid, but there were a couple of things I wanted to tweak. Once I was happy with the plan, I had it save the plan to a Markdown file that would then be the basis for the Code agent to go and work on the actual solution and coding.

Kilo Code even created this diagram as part of the architecture to show the user flow throughout the CLI tool

With the architecture in place, I switched to Kilo Code's Code mode and let it implement the actual solution. It handled all the nitty-gritty details - setting up the TypeScript project, installing dependencies, implementing the GitHub API integration, building the terminal UI with inquirer, and writing the logic to format the prompts. What impressed me was how it maintained a coherent structure throughout the codebase without me having to constantly intervene. The code was clean, well-organized, and properly typed - exactly what you'd expect from a solid TypeScript project.

Refining the Code

The initial implementation was perfectly functional and would have worked fine for basic usage. But as I reviewed the code, I realized there were a few quality-of-life improvements I wanted to make. Rather than diving in to code these myself, I decided to see how Kilo Code would handle incremental refinements. I started new tasks with specific enhancement requests, treating it more like a conversation with a pair programmer than giving comprehensive specs. This approach worked surprisingly well - it understood the context from previous work and could make targeted changes without needing to regenerate everything from scratch.

For example, I realized I wanted the tool to copy the generated prompt to my clipboard for convenience, so I added:

Can you change this to *also* put the issue's prompt onto the clipboard as we are outputting it to the terminal?

Clipboard module Kilo Code made

And later, I thought it would be nice to remember previously used repositories:

Can you have the application write to a config folder (e.g. for mac ~/.config/github-kilo/history.yaml) a history of previously used repositories?

History module Kilo Code made

Each time, Kilo Code adapted the implementation accordingly. There was some back-and-forth fixing minor errors, but the overall process was smooth. The total cost for all revisions? Using the latest model from Google - Gemini 2.5 Flash - a mere $0.4115. That's less than a cup of coffee (less than a refill of coffee?) for a tool that will save me hours of tedious work.

Addressing the Skeptics

I know there are plenty of developers out there who view AI coding tools with skepticism. I get it - I've been there. Common concerns I hear include:

• "AI just generates boilerplate code I could write faster myself"

• "It doesn't understand the nuances of real-world projects"

• "It produces code with subtle bugs that take longer to fix than writing it myself"

• "Using AI means I'm not really programming anymore"

Here's the thing: I don't think that AI coding tools aren't meant to replace your expertise - they're meant to amplify it. In building github-kilo, I wasn't just mindlessly accepting whatever the AI suggested. I was directing the process, making architectural decisions, and using my experience to evaluate the suggestions.

The tool didn't write perfect code on the first try. There were edge cases it missed and optimizations it didn't consider. But it did provide a solid foundation that I could build on, which significantly accelerated the development process.

Rather than thinking of AI as replacing developers, I prefer to think of it as a pair programming partner that never gets tired or hungry - one that might not always have the right answer but can quickly generate options for you to consider.

The Results

The finished product works exactly as I hoped. I can:

• Run the tool in my terminal

• Select from previously used repositories or enter a new one

• Browse through issues or search for specific ones

• Select an issue to generate a prompt that includes all the context

• Have that prompt automatically copied to my clipboard

• Or process all issues in bulk and save them to files

The UI is simple but effective - just enough to make the tool pleasant to use without unnecessary complexity.

What used to take me 5-10 minutes of copying, pasting, and formatting now takes seconds. For someone who regularly uses AI to help with development tasks, that's a significant time savings.

Lessons Learned

After building github-kilo with Kilo Code, here are my key takeaways:

What worked well:

• Starting with a clear description of what I wanted to build

• Iteratively refining the implementation with more specific requirements

• Using AI to handle the "boilerplate" aspects while I focused on the unique aspects

• Testing frequently and addressing issues as they arose

What didn't work as well:

• Very specific implementation details sometimes needed more guidance

• Error handling required more explicit direction than I initially provided

• Some third-party library integrations needed human intervention

Tips for effective AI-assisted coding:

1. Be clear about what you want, but don't feel like you need to specify every detail upfront

2. Test frequently - don't assume the generated code works perfectly

3. Use your expertise to evaluate and guide the AI's suggestions

4. Iterate! Don't expect perfection on the first try

5. Remember that you're still the developer - the AI is just a tool

What's Next?

Building github-kilo was a perfect example of what I think "vibe coding" could really be (e.g. “vibe engineering”) - using AI as a collaborative tool to quickly bring an idea to life. It wasn't about replacing my skills as a developer but augmenting them to make the development process more efficient and, honestly, more fun.

For those skeptical about AI coding tools, I'd encourage you to try this approach. Start with a small, useful project and see how AI can help you build it. You might be surprised at how it changes your perspective from viewing AI as a threat to seeing it as a powerful tool in your development arsenal.

What still amazes me is the economics of this approach. The entire project - including all iterations, refinements, and fixes - cost me exactly $0.4115 using Gemini 2.5 Flash. That's less than the price of adding an extra shot to your coffee. For that trivial amount, I got a working tool that will save me hours of tedious work every month. The ROI here is honestly ridiculous, and it's a clear sign of how AI is shifting the economics of software development in fascinating ways.

This is just the beginning of my "Weekend Vibe Coding" series. Next time, I'll share another project where I used AI assistance to build something useful, exploring different aspects of the AI-assisted development process.

Meanwhile, if you're curious about github-kilo, feel free to check it out and let me know what you think. And if you have suggestions for future weekend projects, I'm all ears!