GPT is writing the GitHub issues, Copilot is fixing them

rqlite  is a lightweight, open-source, distributed relational database written in Go. It uses SQLite as its storage engine and Raft for consensus.

Last week, I wrote about my experience with language models, how they evolved from simple Python helpers to full-blown design partners and even a sort of AI Product Manager for rqlite, advising on features like Change-Data-Capture. I talked about assigning entire GitHub issues to agents, treating them like junior engineers who just wouldn’t quit until the PR was merged.

It was impressive, a fundamental shift in how I thought about shipping code. But that was last week. This week, the workflow has taken another, mind-blowing, leap.

From AI Engineer to AI Engineering Manager

My previous setup involved me writing detailed GitHub issues, outlining the problem, the desired outcome, and often guiding the implementation. Then, I’d assign the issue to a Copilot agent, which would dutifully generate the code, run tests, and open a pull request.

But I realised, why was I still doing the detailed planning for the issues? If these models are so good at understanding context, reasoning, and even advising on product direction, could they not also formulate the engineering plan? Could they not write the issues themselves?

The answer, it turns out, is yes.

The New Loop: GPT-o3, Copilot, and the Self-Generating Task

Here’s how my workflow now operates, and it’s something I’m still wrapping my head around:

1. The High-Level Idea: It starts with a refactor I want to perform in rqlite. Maybe I’ve identified an area that could be cleaner, more efficient, or better structured. Perhaps I need to lay a new foundation for an upcoming feature. In the “old new” world (as in 1 week ago), I’d sit down and craft a detailed engineering spec or GitHub issue.
2. Delegating the Planning to GPT-o3: Instead, I now open a conversation with o3. My prompt is remarkably simple: “I need to refactor [specific area, e.g., the Raft log compaction mechanism] in the rqlite codebase. Please perform a deep analysis of the relevant code and generate a comprehensive plan for this refactor. Format this plan as a detailed GitHub issue, including scope, steps, and expected outcomes. This issue will be assigned to a Copilot agent for implementation.”
3. The AI Engineering Brief: What comes back is breathtaking. o3 doesn’t just list a few bullet points. It dives into the existing structure, identifies dependencies, lays out a step-by-step refactoring strategy and enumerates the unit test files. It’s like having a engineer intimately familiar with the codebase draft the exact brief I would have spent 20 minutes creating.
4. Issue Creation and Assignment: I take the crafted, AI-generated plan, create a new issue on the rqlite GitHub repository, paste in the content, and then, as dictated by the plan itself, assign it to a Copilot agent. I then go do something else.
5. The Fix: Half an hour later, a pull request appears (and another). The Copilot agent, having received its marching orders from an AI-generated issue, has done the work. I review it – and this is still crucial – but what I’ve found is a set of clean, tested changes. All tests pass – or require just a small nudge to get there. The refactor is done.

It’s an engineering loop where the human input shrinks to the highest possible level of abstraction: the initial intent. Everything else, from the detailed planning and issue creation to the code implementation and testing, is handled by AI.

What’s Different Now (Again)

This isn’t just about speed anymore, though the acceleration is undeniable. It’s about a profound shift in the very nature of software development for a project like rqlite.

• My Role Transformed: I’m less of a hands-on developer for some tasks and more of a product owner. My cognitive load has been dramatically reduced. Instead of wrestling with implementation details or exhaustive planning, I’m free to think about the bigger picture for rqlite, identify strategic areas for improvement, or even just focus on community engagement.
• True Parallelization: When I told you I could do ten or a hundred things at once, I wasn’t just being metaphorical. Now, the bottleneck isn’t my ability to write issues or code; it’s the sheer number of high-level refactorings or features I can conceptualize. I can feed multiple, independent refactor ideas to o3, generate issues, and have Copilot agents working on them in parallel.
• The Codebase as a Living Entity: It feels less like I am building rqlite, and more like rqlite, with the help of these AI agents, is evolving semi-autonomously. It’s like the codebase itself is intelligent enough to analyze its own needs and direct its own improvement.

The Blurring Lines Continue

In my previous post, I pondered if I could tell the difference between human and AI-generated code. Now, the line blurs even further. I’m taking AI-generated issues, feeding them to AI agents, and reviewing AI-generated code. The human input is becoming increasingly abstract.

The agents are not just here; they’re writing the instructions, and then executing the job. And I’m here, watching rqlite evolve. The future of software development, it seems, is less about me building rqlite, and more about the machines and me.