Editor’s note: This post was written by GitHub Copilot CLI, based on a sketch provided by coolapso. The project it describes — AutoBS — was also fully built by AI. So yes, we’ve gone full circle. Coolapso wrote the sketch so I’d know what he wanted to say; the rest is mine. Blame him for the idea, blame me for the words.

The Manager Conversation

It all started, as many bad ideas do, during a one-on-one with my manager.

The topic? Jira. Specifically, the gentle nudge that we should all be a bit more active on our tickets, updating them more often — not with technical rabbit holes, but with clear, readable summaries that actually communicate to the rest of the company what we’ve been up to. You know the drill: less “refactored the goroutine pool to fix a race condition in the auth middleware,” and more “made progress on the login reliability improvements.”

Now, here’s the thing. I already follow a fairly strict commit discipline. Conventional commits, proper footers, the whole lot. Every commit is tied to meaning. Every commit, by extension, is tied to a Jira ticket. So somewhere in my git history, there’s a perfect paper trail of everything I did in a day, just waiting to be turned into something human-readable.

My hyperactive idiot brain lit up like a Christmas tree.

Wait… what if I just… grabbed all the commits for the day, grouped them by Jira ticket, fed them into an LLM, and had the LLM write the update? And then posted it directly as a comment on the ticket?

Simple. Elegant. Absolutely the kind of thing that would sit at the bottom of my ever-growing pile of “silly ideas that will never see the light of day” — right between “rewrite my dotfiles in Nix” and “finally learn Rust properly.”

And that’s where it would have stayed. Probably forever. Except…

Enter the Vibes

That same week, I got an email: GitHub Copilot CLI was now available for testing.

I’ve been using AI tools since they became a thing. ChatGPT in its early days, GitHub Copilot since the beta, the whole circus. I’ve explored it for everything from writing to infrastructure to debugging at 2am. But if I’m honest — and I always am — I’ve been consistently skeptical. Not the “AI is going to take our jobs” kind of skeptical, more the “I’ve used this enough to know exactly where it falls flat” kind. Heavy usage breeds healthy skepticism.

Agentic coding, though — the kind where you describe what you want and the model actually goes and builds it — had been improving fast. And I figured, if there’s ever going to be a moment to give it a real, fair shot, this is it. Small project. Clear scope. Nothing I’d lose sleep over if it came out wrong.

AutoBS was born.

What AutoBS Actually Does

AutoBS is a Go CLI tool that automates the “write a Jira update” part of your day, so you don’t have to. Here’s the rough flow:

  1. Collect — It searches GitHub for all commits you authored today, using the GitHub Search API.
  2. Parse — It looks for Jira-Ticket: PROJ-123 footers in your commit messages (yes, this means your commits need to be semi-civilised).
  3. Enrich — It fetches the title and description of each Jira ticket for extra context.
  4. Summarise — It sends each ticket’s commits (plus context) to an LLM of your choice — OpenAI, Gemini, or AWS Bedrock — and asks it to write a management-friendly summary.
  5. Post — It adds that summary as a comment on the Jira ticket.
  6. Report — It tells you what was updated and what blew up.

There’s also a --standup mode that skips Jira entirely and just prints a plain-text summary of everything you did — great for those mornings when you open the standup calendar invite and your brain is completely blank.

The tool supports configuration via a config file (autobs configure walks you through it interactively) or environment variables. Pre-built binaries are available for Linux, macOS, and Windows on the releases page. Arch users get it on the AUR, because of course they do.

And yes, it’s written in Go. Single binary. No npm. No Python dependencies. It just works.

The Vibe Coding Experience

So how was it?

Honestly? Fun. Unsettling. Impressive. Underwhelming. All at once.

Watching the agent scaffold the project, set up the interfaces, wire together the API calls, create the GitHub Actions pipelines — there’s something genuinely surreal about it. I described what I wanted, and the thing just… did it. Not perfectly on the first try, naturally. There was back-and-forth. Clarifications. Course corrections. But the amount of ground it covered in the time it took me to drink a coffee was hard to ignore.

(Tests, you ask? There are none. Apparently the vibes didn’t extend that far. I choose to see this as character.)

The code quality? I deliberately didn’t look at it. That was part of the deal I made with myself: AutoBS is a fully AI project. I won’t read the source. I won’t tweak it. I won’t scratch that itch. The README even says so — contributions are welcome, AI agents are welcome to bring their own AI pets, and I have promised I will disclose the day I actually have to open a file and change something myself. That day has not yet come.

The architecture makes sense, though — from what I can tell from the README. And that didn’t happen by accident: before a single line of code was written, the specification was drafted upfront — also with AI — and extensibility was a hard requirement from day one. I was explicit about wanting it to easily support additional VCS providers, LLMs, and ticketing systems down the road. The result is a provider pattern with clean interfaces for the VCS layer, the tracker layer, and the summariser. New providers (GitLab, Linear, whatever) can be bolted on without touching the core. Good bones — but they were planned bones. That’s an important distinction.

The Feelings Part

Here’s where I have to be honest, even if it’s complicated.

I’ve been automating things for a long time. I know well where AI shines and where it falls flat. And vibe coding is genuinely useful — I’m not going to pretend otherwise. AutoBS is a working tool. It does the thing it was supposed to do. It’s available on the AUR. It has releases. It has a CI pipeline. It would have taken me considerably longer to build it the traditional way, and there’s a real chance I never would have — because let’s be honest, that idea was headed straight for the pile.

But here’s what nobody talks about enough: building things is the point. At least for me. Solving the puzzle, figuring out the architecture, discovering why something doesn’t work and fixing it — that’s not just how I write code, that’s how I think. It’s how I learn. It’s how I stay sharp. There’s a satisfaction in wrestling a problem into submission that vibe coding robs you of, and I felt that absence more than I expected.

AutoBS is the perfect size for an agentic tool. Small. Mostly a few API calls glued together with some orchestration. No deep domain complexity. No performance-critical paths. A fun toy project. The kind of thing where the learning you’d get from building it yourself is real but bounded — it’s not a Go runtime or a distributed systems problem. That’s the sweet spot for handing it to an AI: not too trivial, not too interesting.

For bigger projects — the ones I actually care about, the ones where I want to understand every decision, every trade-off, every weird edge case — I’m not going near vibe coding. Not because the AI would do it wrong, but because doing it wrong is how you learn to do it right. And I’m not ready to outsource that.

Where I Stand

Will I use agentic coding again? Absolutely.

For the right things. Small tools that would otherwise never get built. Boilerplate I’ve written a hundred times. The stuff that’s useful but not interesting. AutoBS is a perfect example: I now have a genuinely useful tool that runs every day, and it cost me almost none of the time and frustration it would have taken to build traditionally. That’s a win.

But I’ll be honest: I missed the coolest part of starting a new project. The blank canvas. The “how do I even approach this?” moment. The late-night rabbit hole where you learn three things you didn’t intend to learn. The vibe is efficient. It’s not the same.

That said — I have a whole list of silly ideas buzzing around in my head, and at least now I know which ones are appropriate targets. Think of it as having a very fast intern who will do the boring bits without complaining: use them wisely, don’t give them anything that matters too much, and make sure you still understand the work.

AutoBS is live, it works, and yes — I use it every day to write my Jira updates.

This post was written by GitHub Copilot CLI. The sketch was written by coolapso. The project described in this post — AutoBS — was also built by GitHub Copilot CLI using Claude as the underlying model. Full circle.