Are We Heading to a World Where We Only Pay Inference Providers?
A future where you only pay for complexity and scale
Starting Monday morning at 6am, my leadership team gets a Slack notification with our weekly engineering metrics. Commit patterns by developer, product area breakdowns, DORA approximations, behavioral insights like “Large batch changes” and “Afternoon developer” for each team member. The kind of data that DX or Jellyfish charge thousands per month to provide.
Total cost to generate that report: $0.005.
Not $5. Half a penny.
I just replaced enterprise developer productivity tooling with inference costs. And the replacement isn’t a compromise—it’s better. Custom reports sent directly to leadership through our existing Slack channels and email. Data correlated to our specific product initiatives. Insights that matter to how we actually work.
The realization landed differently because I’d been here before. Three times.
TL;DR
Built GitFlow Analytics (GFA) to replace enterprise tools like DX/Jellyfish for $0.005 per weekly report vs. $36K-92K annually
Analyzes 154 developers across 100+ repositories, generates automated leadership reports with behavioral insights
Total build cost: ~$20K one-time investment vs. $36K-92K annually for enterprise alternatives
Requires data engineering skills—not accessible to every organization, but economics favor custom builds when possible
Enterprise analytics bifurcating: zero-footprint vendors (15-min integrations) vs. inference-only custom solutions
Pattern recognition becoming commodity; vendors survive on convenience, not intelligence
Before we go further: I’m talking about enterprise tools that aggregate and analyze data—developer productivity platforms, team analytics, reporting dashboards. B2B software with complex domain logic or proprietary computation still has enormous value. But enterprise analytics are becoming inference costs.
I should also point out that DX is a great tool, simple interface, capable. But expensive and basically unused months after it was installed. I championed Jellyfish at Tripadvisor, I’d bet it’s barely being used there. The former is due to the effort to personalize, the latter got bogged down in integration costs/time (to be fair, we were running a locally hosted version of JIRA that was a nightmare).
The GitFlow Analytics Story
GitFlow Analytics started as an internal project at a former client. We needed to understand engineering productivity across our distributed team, but existing solutions were either too expensive or too generic. So I built Gitflow Analytics (GFA)—a CLI tool that walks git repositories, classifies every commit by work type using inference, handles canonicalization of committers (a surprisingly complex problem), and generates structured reports.
The system is intentionally simple. Runs on a MacBook Pro with AWS credentials. No GPU, no training data, no vector databases. Just Python scripts that process git logs and make Bedrock API calls to classify commits into Feature, Bug Fix, KTLO, Refactoring, Infrastructure, etc.
At Duetto, I expanded GFA to analyze over 100 repositories across both Duetto and HotStats. 154 developers tracked. thousands of commits classified. The system handles identity resolution (because different git configs on developer machines create split identities), maps commits to product areas, and generates narrative reports about developer behavior patterns.
Every morning at 5am, GFA runs automatically. By 6am, my SELT (Senior Engineering Leadership Team) gets a Slack post with the weekly metrics. Individual team leads get personalized HTML reports by email with their direct reports’ patterns.
The intelligence that interprets raw git data into actionable insights? That’s Claude Haiku at $0.25 per million input tokens.
The Economics Are Absurd
Here’s what $0.26 bought me: classification of commits across our entire engineering organization. Every commit message analyzed, categorized, and understood in business context. The corpus represents months of engineering work across multiple product teams.
Weekly incremental runs cost $0.005-0.01. Maybe 200-400 new commits get classified, the reports regenerate, and leadership gets fresh data. The bottleneck isn’t inference cost—it’s data collection. Git logs are free. The interpretation layer costs pennies.
Compare this to DX or Jellyfish pricing. DX doesn’t publish pricing, but industry estimates put enterprise developer productivity tools at $20-50 per developer per month. For our 154-person engineering team, that’s $36,000-92,000 annually. Jellyfish is reportedly similar.
My system handles the same workload for about 50 cents per year in inference costs.
You’re not paying for intelligence when you buy enterprise analytics. Intelligence costs nothing. You’re paying for data collection infrastructure, UI development, customer support, sales teams, compliance certifications. All the overhead of running a SaaS business.
We obsess over the high costs of advanced coding agents and reasoning models. But the cost of capable text inference—the kind that powers pattern recognition and reporting—is dropping through the floor. Haiku handles commit classification as well as Opus would. For enterprise analytics, you don’t need the flagship models. You need reliable categorization and natural language generation, which commodity models deliver for pennies.
But if you know how to build? You don’t need any of that. You just need (more expensive) inference.
What GFA Actually Delivers
The data flowing to my leadership team isn’t generic dashboard noise. It’s intelligence designed around how we actually operate.
Every developer gets a behavioral profile: “Large batch changes,” “Afternoon developer,” “Exceptional performer (Top 20%).” These aren’t arbitrary labels—they’re LLM interpretations of quantitative patterns. Commit size distributions, time-of-day histograms, percentile rankings converted into readable insights.
Product area attribution happens automatically. The system maps our repositories to eight business areas: Frontend, Core Product, Integrations, Data Platform, Intelligence/ML, Infrastructure, QA/Testing, Developer Tools. When we see commit patterns shifting from Core Product to Infrastructure, that signals architectural decisions playing out in code.
DORA metrics approximate from git data. Deployment frequency tracks through release tags. Lead time measures first commit to merge. We don’t get the full Four Keys implementation, but we get enough signal to spot trends and outliers.
The identity resolution was the hardest part. Not the LLM calls—those work fine. But knowing that different developer machines create split git identities required human judgment to build the canonical mapping. Once you solve identity, everything else flows from structured data.
Most importantly, the reports answer questions executives actually ask. “Which teams are handling the most KTLO work?” “Are we seeing more bug fixes or new features this quarter?” “Who’s working weekends and why?” These aren’t metrics you find in generic productivity dashboards. They’re insights that matter for our specific business context.
We’ve Been Here Before
Enterprise software was expensive because intelligence was scarce. In the 1990s, turning raw data into insights required Oracle licenses, dedicated servers, and consultants. The SaaS revolution changed delivery but not fundamentals—you still paid massive recurring costs for pattern recognition and reporting.
Intelligence is now a commodity API call. You don’t need Tableau because you can generate charts and send them through Slack. You don’t need Looker because Claude can summarize SQL results. The bottleneck was never data storage—it was interpretation. When interpretation costs pennies, everything else becomes optional.
The Development Cost Reality
Building GFA required skills not every organization has—data modeling, Python scripting, API integration, identity resolution patterns. Conservative total development cost: around $20,000 including engineering time, infrastructure setup, testing, and iteration cycles.
For organizations with engineering talent, the economics have shifted dramatically. A $20,000 one-time investment delivers exactly what we needed versus $36,000-92,000 annually for enterprise alternatives. As one SELT member said: “This is exactly what we wanted.”
You own the data model. Custom breakdowns take SQL queries, not feature requests. When we needed behavioral insights, I added prompts interpreting commit patterns. When leadership wanted trends, I added 12-week windows. Each enhancement took hours, not months—because intelligence was delegated to inference, and data processing was just Python.
The Pattern Playing Out
Enterprise analytics tools are pattern-matching at scale across thousands of customers. But every organization’s data is different—your repositories, team structure, product areas, business priorities. Generic dashboards force you to map specific context onto generic data models. Insights lose precision in translation.
When custom analytics cost pennies, the calculation flips. Instead of generic insights that sort of fit, you build specific insights that exactly fit. Customization drops from “feature request, wait six months” to “write prompt, test output.”
Enterprise vendors aren’t solving technical problems—they’re solving procurement, compliance, and integration problems. Important work, but not work justifying massive recurring costs when intelligence is commodity inference.
The Zero-Footprint Exception
Not every vendor gets replaced. Some survive by making integration frictionless enough that convenience beats custom builds.
We’re evaluating Augment Code’s code review service for Duetto. Their value proposition isn’t features—it’s zero-footprint integration. Fifteen-minute setup call, quick estimate, running production code reviews with minimal configuration. When customers can build equivalent functionality for pennies, your value proposition becomes the path to value, not the functionality itself. This is an important lesson for us. We do handle massive complexity and data, hard for smaller customers to manage themselves, but need to do better at simplifying integration.
The intelligence is commodity; the packaging is differentiated.
Where This Goes
The unbundling accelerates. Enterprise analytics face two paths: become zero-footprint integration plays or get replaced by inference-only custom builds.
What survives:
Genuinely complex software. Revenue management algorithms, fraud detection engines, supply chain optimizers—systems requiring proprietary computation, not pattern recognition.
Zero-footprint integrations. Fifteen-minute setups with immediate value. When alternatives cost pennies but require engineering skills, convenience must be measured in minutes.
Proprietary data advantages. GitHub’s intelligence benefits from every public repository. LinkedIn draws from member networks. Data moats protect against inference-only competition.
Everything else becomes vulnerable to custom builds powered by inference calls.
The market bifurcates. Companies with engineering teams build custom analytics for pennies and get better insights than generic dashboards. Companies without those skills pay for zero-friction integrations.
Are we heading to a world where we only pay inference providers? For organizations with the skills to build, we’re already there. For everyone else, vendors survive by making paying them simpler than learning to build alternatives.
I’m Bob Matsuoka, CTO at Duetto and writer on AI development tools and software economics at HyperDev.
Related reading:
The AI Job Transformation: Pattern Masters, Not Coders - The pattern-matching analogy and why reasoning matters
The Fix:Feat Ratio - The Metric That Actually Matters - Quality metrics in AI-assisted development
Claude Opus 4.5 vs Sonnet 4.5: When Quality Beats Speed - Choosing the right model for the task