Since launching in early September, Auggie CLI has seen one of the fastest adoption curves in company history. Today, more than half of the people who use the CLI use it as their primary agent.
Reflecting on the success of this project, the decision to use Auggie CLI as soon as possible in order to build Auggie CLI shaped everything about how the tool works today. The problems we discovered, the features we prioritized, and the product decisions we made all came from the daily friction of depending on our own half-finished product. In this blog post, I’ll share the iterative process we used to help a small team take a new product from idea to reality in less than two months.
Automation-first design
The initial shape of what we were building for the CLI was the result of a lunch time conversation between our co-founder, Guy, and me. Guy was talking about the CLI tool that he was building, and I mentioned that if I could pass a GitHub token to this CLI, we could use it to automate things on GitHub like code reviews and descriptions for PRs.
As developers building tools for developers, if we feel like something is cool, it’s a good signal that it’s something our users would like too, and that’s what happened here.
Automation was the start of "Guy is building a thing" becoming "we're building a CLI product." This is also a major factor in why we wanted automation to be first class for the CLI: we already had ideas on how it could make our own workflows more efficient. This led to decisions like:
- Non-interactive mode with
auggie --print "instruction"for CI/CD - GitHub Actions integration with official actions like
augmentcode/augment-agent,augmentcode/review-pr, andaugmentcode/describe-pr - One-shot execution capabilities for scripting to easily integrate into build processes and workflows
Beyond automation: rich terminal experience
As the tool was starting to get built out, it was built for a dumb terminal with an automation focus. However, we realized that we needed some amount of interactive use to test it and make it usable for more than just automation. That's when we had someone join the team that focused pretty much entirely on building us a really good interactive experience with Ink. This architecture choice provides a rich, interactive terminal experience using familiar React patterns while maintaining the ability to also run in non-interactive modes for automation and CI/CD scenarios.
‘Just me and the agent’
As that interactive experience took shape, the CLI rapidly became the go-to agent for everyone on the team. We were all starting to use it far more than we would use the agent in the IDE. I myself am not a terminal person. I don't use a terminal like Ghostty and I don't have a million settings for my IDE. Yet here I was, working exclusively with a terminal tool and liking it far more than anything I had used before.
I find that most great dev tools are born from the needs of the people that build them, so I was wondering what about the CLI made it so great for me, someone who rarely found themselves in a terminal before that.
That's when I came to the realization that it was the simplicity of the CLI — the fact that it felt like just me and the agent — that I loved. That realization has become a core part of how we build the CLI. The goal was the power of a terminal with the ease of use of a chat message.
The TUI provides real-time responses and streaming output, making it feel like a conversation rather than batch processing. We implemented what feels like a natural command flow that feels more like chatting with a coworker:
- Slash commands that feel like chat commands (
/code-review) - Prompt enhancements via
Ctrl+Pto improve your requests - Multi-line prompt navigation that works like natural text editing
An escape hatch for creativity
By this point, the team had grown again, and we were about four people. We'd already seen great results internally on the team and had just released an alpha to some of our customers. This was when we realized just how powerful what we were building really was.
Beyond the simple automation tinkering I had been doing, we saw a power user create a whole swarm of Auggie agents, using markdown files for coordination and running across many machines. This gave us the final pillar around our decision making for Auggie: be an escape hatch for creativity. No matter how clever we are or what cool ideas we can think of, they pale in comparison to the ideas our customers have for using our products.
Our philosophy is to provide powerful primitives rather than rigid workflows to allow your creativity to flourish in ways you may not have even conceived of yet. This is supported by a flexible architecture that enables unexpected use cases with the help of:
- The ability to create custom reusable prompts as markdown files that become available as slash commands
- Markdown-based coordination that allows users to create sophisticated agent configurations and workflows that go far beyond simple automation
- Distributed agent deployment supported by GitHub Actions integrations, CI/CD automation capabilities, and remote agent concepts
And all of this is backed by our Context Engine, which leverages your real-time semantic index to understand cross-file dependencies, architectural patterns, and project-specific conventions across your entire codebase, making results more useful from the first interaction. This context awareness enables the sophisticated automation workflows that have driven CLI adoption, allowing teams to build reliable, codebase-aware automations that would be impossible with context-blind tools.
The results have been impressive. We’re seeing users build sophisticated automation workflows to help with tasks like summarizing PRs, triaging errors, refactoring code, and streamlining experimentation and prototyping.
Experience Auggie CLI for yourself
Each phase of building Auggie CLI taught us something new and every insight came from actually using what we were building. What started as a lunch conversation became something our customers are using in ways we never imagined, and this is just the start.
Auggie CLI is available to all users. Try it at augmentcode.com/cli.
Written by
Nathan Rockenbach
Member of Technical Staff
Nathan is a seasoned software engineer and AI-focused technologist with a passion for building developer tools that enhance productivity and code quality. At Augment Code, Nathan works on innovative solutions that empower developers and streamline workflows. With a background that includes influential roles in developer infrastructure and productivity tooling, he brings deep technical insight and real-world experience to every project and discussion. Outside of coding, Nathan enjoys exploring advancements in AI and sharing perspectives on tech trends with the broader community.