AI-Assisted DevOps: Driving Git and GitHub with Gut
Lightning Talk with Clelia Astra Bartelli
In the world of software development, certain tools are as essential as they are frustrating. Git, the powerful version control system, is perhaps the chief example — a daily companion for millions, yet a source of frequent confusion and anxiety. It was this universal friction point that Clelia Astra Bertelli, an open-source contributor at LlamaIndex, addressed in a recent session of Elite AI Assisted Coding. She didn't just present a tool; she presented a philosophy, one that champions a more deliberate, predictable, and human-centric approach to AI-assisted development. At the heart of this philosophy is her project, gut.
The Philosophy: Why Gut Isn't Just Another AI Agent
The story of gut began, as Bertelli cheerfully admitted, with a simple, relatable typo. This moment of human error sparked a powerful question about human-computer collaboration.
What if I build something that is called gut and that is basically something that is... AI-powered and it helps me with git and gh... because git is like really a hell for me sometimes and for a lot of developers.
This core idea — to tame the "hell" of git — led her to a critical design choice. In an industry captivated by the promise of fully autonomous AI agents, Bertelli chose a different path: a structured, event-driven workflow. She drew a sharp distinction between the two, framing it as a choice between predictability and chaos. While agents offer autonomy, she argued, their behaviour can be dangerously unpredictable in high-stakes environments like a developer's terminal.
Workflows offer you something that agents... don't offer you, which is predictability. You know what events go in and you know what events go out in workflows. With agents, it's a little bit more messy. There is a lot of autonomy, which is great, but most of the times it's unpredictable and sometimes it causes a mess before you're there to fix it.
This principle of predictability is the philosophical bedrock of gut. Bertelli's goal wasn't to build a magical black box that tries to guess the developer's every intention, but rather a transparent and controllable assistant that automates tedious tasks without seizing control. She encouraged the audience to embrace this model for complex, sequential work.
That's why I encourage, generally I encourage people to take on workflows more than on building gigantic, big, gigantic agents with a hundred of tools that can just like get things confused and a little bit messy.
Inside Gut: Anatomy of a Human-in-the-Loop Workflow
With the "why" firmly established, Bertelli delved into the "how." gut operates in two primary modes, both designed to serve the developer in a transparent way. The main interface is an interactive session where a developer states their goal in plain English. The tool then initiates a precise, multi-step process to translate that intent into a correct and safe command.
Command Analysis: First, gut parses the natural language input to understand the core intent.
Command Selection: Based on the analysis, it chooses the appropriate underlying tool — git or the GitHub CLI, gh.
Parameter Mapping: It then determines the precise subcommands, flags, and options needed to construct the full command.
Explanation & Human in the Loop: Finally, before any action is taken, it presents the generated command along with a clear explanation of what it will do. This final step is the most critical.
Bertelli emphasized that this last step, the explicit confirmation from the user, is the most important feature of the entire system. It acts as a crucial safety valve, preventing the AI from making unapproved changes.
This is, I think, the crucial part in every workflow that has to do with a developer. It has to do with coding and it has to do with AI assisting you. AI doesn't have to do the whole job because that would expose you to a lot of troubles, a lot of problems, especially if you're pushing to production... We want to have at least one checkpoint in which the human is in the loop.
The tool's second mode transforms it from an assistant into a tutor. By passing a failing command to gut, a developer can ask for an explanation of what went wrong. The tool analyses the command, explains the underlying git concept the user might be missing, and provides a corrected version. This feature is particularly aimed at demystifying git for those new to the field.
Underpinning these features is a modern, practical tech stack:
LLM: The system uses Groq to serve the Llama 3 70B model, which Bertelli praised for its excellent instruction-following capabilities.
Architecture: The entire system is orchestrated using the Workflows feature within LlamaIndex.
CLI Display: The rich terminal interface is built with Textualize.
Live Demo: Gut in Action
The presentation then transitioned from theory to a live, compelling demonstration. Bertelli opened her terminal and, using gut as her partner, performed a complete development cycle on a Next.js boilerplate project. She made a simple code change and then, with a series of conversational requests, had gut check out a new branch, add the files to staging, commit them with a message, and push the branch to the remote repository.
The true power of her human-in-the-loop philosophy was revealed when she tasked gut with creating a pull request. The AI's first attempt was incorrect. But this wasn't a failure of the system; it was the system working exactly as designed. It presented a flawed command, and the human expert — Bertelli — was there to gently correct it.
It tells me
gh pr checkout 321. That's not correct because this would basically mean that it's checking out a PR for me... And so I would say probably go withgh pr create.
With that simple feedback, gut generated the correct command on its next attempt and successfully opened the pull request. This brief, interactive moment was the perfect microcosm of her entire argument: a partnership where the AI provides speed and automation, and the human provides oversight and critical judgment.
She concluded the demo by showcasing the tool's educational value. After intentionally writing a failing git command, she fed it to gut for analysis. The tool returned a patient, clear explanation of the concept of staging files, transforming a moment of frustration into a learning opportunity.
This is great for learning because especially if you are, I would say, a junior engineer and like facing the world of Git for the first time, there's a lot of commands there that are very scary that you don't know how to use.
Developer Insights: A Conversation
After the main presentation, the session evolved into a fascinating Q&A, offering a deeper look into Bertelli's personal workflow, technical choices, and views on the open-source community.
On Productivity and Partnering with AI
When asked about her prolific output as a contributor to nearly thirty different projects, Bertelli described a pragmatic and balanced partnership with AI. She doesn't outsource her thinking but uses AI as a tool to overcome specific roadblocks, estimating that it plays a role in 30-40% of her coding.
Sometimes I come to a point where I say, okay, I want to write this code. I have in mind what I want to write. I know how the implementation should work, but I keep hitting the same point where I don't know how this could work really well in code. So I go to Claude... and I ask, 'Hey Claude, can you give me a hand?'
She described an iterative process of prompting, testing the AI's output, providing feedback, and repeating the cycle three or four times. Once the solution is viable, she reclaims full authorship. "When I feel I'm in a good spot," she explained, "I take back the control over the code and make the modifications I need to make it final."
The Journey from Python to Go
The conversation then shifted to her choice of programming languages, particularly her growing advocacy for Go. Her motivation, she shared, was born from a specific struggle with Python's concurrency model.
Writing this asynchronous code in Python... is my personal hell.
This challenge drew her to Go, where she found the philosophy around "goroutines and managing different routines at runtime and queues and pipelines" to be far more intuitive. However, she noted a significant gap in the ecosystem: Go is currently lagging in the AI revolution.
As you said, there's a reason why you don't hear about AI in Go — is that the environment is underdeveloped... there is a lot of basics, like event-driven workflows, that are missing there. And that I think the future will fill out, but we need to start filling them out now if we don't want Go to miss out on the AI revolution.
This observation is not just a critique but a call to action, explaining the motivation behind her own projects like workflows-go, which aim to build those missing foundational pieces.
A Philosophy of Open Source Collaboration
Finally, Bertelli shared her approach to managing open-source projects and fostering a healthy contributor community. She strongly advocates for an "issues first, then PRs" model, where a discussion precedes any significant coding effort. This, she argued, is a matter of respecting contributors' time and energy.
I generally prefer taking issues before really diving deep into a pull request because maybe the issue is something that is not well explained in the docs and could be resolved with that, instead of a person just digging hours and hours to find a solution... and then maybe it was just something that was not clearly explained.
Once an issue is discussed and a path forward is agreed upon, she believes in empowering the contributor to take ownership of the feature.
I generally encourage people to take the lead... You own this feature, that's yours. You can make the pull request. I will review it.
👉 Gut