PostHog says it makes your product self-driving. The reality is more like advanced cruise control, and the distinction matters for every team considering agent-driven workflows.
PostHog has repositioned itself around a bold metaphor. Its GitHub repository now describes the platform as "the leading platform for building self-driving products," promising tools that "capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes." Its homepage goes further: PostHog "automatically diagnoses problems, fixes bugs, and generates pull requests, all without you having to prompt it."
That's a compelling pitch. It's also one that deserves scrutiny. Because buried in the same description is a quieter admission: you "steer it all from Slack, web, desktop, or the MCP" (GitHub - PostHog/posthog). Self-driving, in other words, but with a human at the wheel.
What PostHog Actually Captures
To understand the gap between the marketing and the mechanics, start with what the platform collects. PostHog's GitHub listing bundles AI observability, product analytics, session replay, feature flags, A/B experiments, error tracking, and logs into a single platform. Each of these tools generates structured data about how a product behaves in production and how users interact with it.
Session replay records what users actually do. Error tracking captures crashes and exceptions. Feature flags let teams toggle functionality for specific user segments. Experiments measure the impact of changes. AI observability monitors the behavior of AI-powered features. Logs provide the raw operational trail.
Together, these tools create a rich contextual layer. The idea is that AI agents can consume this data and act on it: identifying a spike in errors, correlating it with a recent feature flag change, and generating a pull request to fix the underlying issue. That's a genuinely useful feedback loop. It compresses the time between "something broke" and "here's a proposed fix" to minutes.
But data collection is not decision-making. And diagnosis is not judgment.
The Steering Problem
PostHog's own description reveals the tension at the heart of its positioning. The platform promises autonomous action, then immediately notes that developers steer it from Slack, web, desktop, or MCP (Model Context Protocol, a standard for connecting AI agents to external tools and data sources).
This isn't a contradiction, exactly. It's a design choice. But it undermines the "self-driving" metaphor in important ways.
A self-driving car navigates without human input. It chooses routes, avoids obstacles, and makes real-time decisions about speed and lane changes. The driver sets a destination and trusts the system. PostHog's model is closer to a highly capable co-pilot that flags issues, suggests solutions, and drafts code, but still requires a human to approve, redirect, or override at every meaningful decision point.
That's not a criticism. For most engineering teams, full autonomy over production code changes would be terrifying. The question is whether the "self-driving" framing sets expectations that the product doesn't meet, and whether that gap creates real confusion about where human responsibility begins and ends.
Where Human Judgment Remains Load-Bearing
Consider a concrete scenario. PostHog's agents detect a 15% increase in checkout errors correlated with a new feature flag rollout. The system generates a pull request reverting the flag. Sounds great.
But what if the errors are concentrated in a single browser version that accounts for 2% of traffic? What if the feature flag is tied to a revenue-critical A/B test that leadership specifically approved? What if the "fix" introduces a regression in a different user flow?
These are judgment calls that require business context, organizational knowledge, and risk tolerance. No amount of session replay data or error logs can substitute for a product manager who knows the strategic priority, or an engineer who understands the architectural tradeoffs of a revert versus a targeted patch.
PostHog's tooling gives agents excellent observational data. What it can't give them is the organizational graph: who cares about this feature, what's the cost of rolling it back, and what downstream systems depend on the current behavior.
What This Means for Teams
For development teams evaluating agent-driven workflows, the practical implications break down along a few axes.
Speed gains are real, but bounded. Automated diagnosis and PR generation genuinely accelerate the feedback loop between production issues and proposed fixes. For teams drowning in operational noise, having an agent triage errors and draft patches is a meaningful productivity improvement.
Review overhead shifts, it doesn't disappear. Every agent-generated pull request still needs human review. Teams adopting this model aren't eliminating work; they're converting debugging time into review time. That's often a good trade, but it's not the same as removing humans from the loop.
Trust calibration takes time. Teams will need to develop intuition about when agent suggestions are reliable and when they're confidently wrong. Early adopters will likely over-review everything, negating some of the speed benefits. Over time, teams may develop too much trust, rubber-stamping agent PRs without adequate scrutiny.
MCP integration matters more than the marketing suggests. The Model Context Protocol is how developers actually control what agents can see and do. It's the real governance layer. Teams that invest in configuring MCP boundaries carefully will get better outcomes than those who treat the system as a black box.
TechCrunch made a related point in a 2024 piece on developer experience: the most effective way to improve developer productivity is to improve developer experience, not to measure output or automate decisions. Andrew Boyagi, who leads DevOps Evangelism at Atlassian, argued that "happy employees are productive employees" and that organizations waste disproportionate effort trying to measure productivity rather than investing in the conditions that enable it.
PostHog's tools could improve developer experience by reducing toil. But if the "self-driving" framing leads teams to treat agent output as authoritative rather than advisory, the experience could degrade quickly.
Autonomy vs. Assisted Decision-Making
The word "autonomy" gets used loosely in developer tooling. PostHog's model is better described as assisted decision-making with automated execution. The agents observe, diagnose, and propose. Humans approve, reject, or modify.
This is a meaningful capability. It's also not new in concept. CI/CD pipelines have automated testing and deployment for years. Static analysis tools flag potential bugs before code ships. What PostHog adds is a richer observational layer, connecting production behavior data directly to agent-driven remediation.
The "self-driving" branding positions this as a category leap. The underlying mechanics suggest an evolution. That's not a knock on the product. Evolutions compound. But teams making adoption decisions should evaluate what PostHog actually does, not what the metaphor implies.
Our coverage of Meta's Tulsa data center explored how infrastructure powering AI workloads is scaling rapidly. The compute capacity to run sophisticated observability agents in real time is increasingly available. The bottleneck isn't processing power. It's trust, governance, and the organizational readiness to let agents act on production systems.
What Comes Next
PostHog's bet is that the gap between "assisted" and "autonomous" will close as agents get better at incorporating business context, not just technical signals. If future iterations can ingest product roadmaps, understand organizational priorities, and weigh business risk alongside technical risk, the "self-driving" metaphor might start to fit.
For now, the honest framing is this: PostHog builds a strong observational foundation and connects it to AI agents that can act on what they see. Developers remain in the driver's seat. The steering wheel is smaller, the mirrors are better, and the car occasionally suggests a lane change. But nobody should take their hands off the wheel yet.
