At Gitar, we’ve been dogfooding our own agentic AI product, and it’s dramatically transformed how we build software. Our development velocity has shifted into overdrive. Since deploying our agents, we’ve seen a 5x acceleration in PR merges, and over the past month, our AI agent has committed more code than any individual engineer.

But just as importantly, it’s transformed how we collaborate, how we review code, and how we design workflows. This shift has pushed us to build new tools, rethink our development practices, and continuously improve the agent itself. What started as an acceleration has become a reinvention and a fundamentally new way of working.

Measurable Velocity Gains

At Gitar, we make decisions based on data. Our mission is to build end-to-end developer tools that meaningfully improve productivity, so we pay close attention to engineering velocity and measure it religiously.

Two core metrics we track are:

PR merge throughput, a direct indicator of team-wide development velocity
Commit throughput per engineer, which reflects individual developer output

After introducing our agent into daily workflows, both metrics saw dramatic, measurable increases. We reached a true inflection point.

To mark our progress, we celebrate every 1,000 PRs merged into our monorepo. Here’s how the pace has changed over time:

PR #5000 → #6000: 80 days (pre-agents)
PR #6000 → #7000: 44 days (early Gitar agents)
PR #7000 → #8000: 15 days (full Expert agent rollout)

That’s a 5x speedup, achieved without increasing team size or reducing PR complexity.

The shift is equally visible in commit-level data. Most code changes are now initiated by the agent, rather than manually typed by developers. By offloading repetitive tasks and automating code maintenance, we’ve scaled output while avoiding burnout. This isn’t about replacing developers—it’s about amplifying them.

Dogfooding: Sharpening the Product, Boosting the Team

Dogfooding helps us build a better product and is an important element of our engineering culture. We rely on our agents the same way our customers do. This helps us uncover bugs, friction points and usability gaps early. It also allows us to build and improve based on shared use cases.

But dogfooding doesn’t just improve the agent; it also improves us. Our engineers actively shape the product: tuning its reasoning, refining its strategies, and upgrading its tools. When the agent underperforms, it becomes an opportunity to debug alongside it and make it stronger.

This creates a powerful feedback loop:

The more we use the agent, the more edge cases we uncover
The more we improve the agent, the more complex tasks it can handle
Each improvement lifts team productivity even higher

Collaboration in an Agentic World

Dogfooding our Agent has also transformed how we collaborate. We no longer think solely in terms of tickets and tasks. We now think in terms of agentic workflows.

Our developers:

Create and evolve agents together as shared team assets
Review agent runs, including plans, reasoning, and diffs, not just code.
Provide feedback on agent behavior, pooling insights to improve performance
Co-develop reusable prompts for complex, multi-project changes.

A well-crafted agent is like well-written code: reusable, reviewable, and refined over time. Our process now includes collaborative discussions on how agents approach tasks, the soundness of their reasoning, and how their output aligns with intent.

This has led to greater transparency, better tooling ideas, and a stronger engineering culture grounded in shared understanding between humans and machines. Over time, these agents capture our engineering knowledge.

Adapting to the Agentic Workflow

As the agent takes over more of the mechanical aspects of coding, engineers have evolved from writing code line by line to orchestrating high-level workflows.

Here’s what that looks like:

Parallel development: Engineers manage multiple PRs at once, using agents to coordinate changes across branches and projects within our monorepo.
Reduced reliance on the IDE: Many workflows move directly from prompt to code review without opening an editor or CLI.
Greater focus on code review, testing, and steering: With higher PR throughput, more effort is spent validating and guiding changes.

Engineers are no longer focused on a single pull request or bugfix at a time. They guide multiple AI-driven code changes, setting direction, and making strategic decisions while the agent executes.

This has created a new mode of working:

Engineers launch and manage multiple agent-initiated branches
They write prompts describing outcomes and code changes rather than manual edits
They review, validate, and course-correct agent output instead of building from scratch

New Tools for a New Paradigm

This “pilot-mode” of development calls for new kinds of tools. We’re building them as we go:

Dashboards for tracking multiple concurrent, agent-led changes
Interfaces for reviewing and refining AI-generated diffs at scale
Context-aware systems for managing conflicts across branches and workflows
Structured natural language interfaces for batching and prioritizing coding goals
Collaborative spaces where teams can learn from one another’s agent runs

Thanks to dogfooding, we’ve been able to identify these needs early and experiment with solutions. In many ways, we’re designing the cockpit while we fly the plane. And that’s exactly the point. The way we build our product now evolves in tandem with how we use it.

Conclusion: Building the Future by Using It

Dogfooding our own agentic AI hasn’t just improved productivity, it has transformed the way we develop software. We've seen measurable velocity gains, with 5x faster PR throughput, and a growing share of commits now generated by our AI. But the impact goes far beyond the numbers.

By making our product central to our workflow, we've changed how we collaborate, review, and build. Engineers are no longer just writing code. Instead, they are guiding intelligent agents, designing workflows, and managing parallel efforts across projects. This shift has created a more productive engineering process.

None of this would be possible without our deep investment in dogfooding. It has allowed us to uncover edge cases, improve the agent’s reasoning, and shape the tools required to support this new way of working. We’re building a product for the future of software development and using it to build that future at the same time.

Agentic development at Gitar is no longer an experiment. It’s our new standard. And we’re just getting started.

How We Used Our Own Agentic AI to Boost Development Velocity