Data: Wikimedia Commons' CC0 Stack Overflow dataset, based on Stack Exchange Data Explorer query 1903717. June 2026 is excluded because the month was incomplete when the dataset was updated.
Stack Overflow questions had been declining before ChatGPT arrived. The fall became much steeper after 2022, from 109,480 questions that November to 1,342 in May 2026.
Question volume isn't the same as site usage, and this chart can't tell us whether an agent retrieved Stack Overflow content behind the scenes. It does capture a change most developers recognise. Instead of writing a public question and waiting, you can ask inside the tool where you are already working. Stack Overflow's own 2025 survey found that 84% of respondents used or planned to use AI tools in development, while 51% of professional developers used them daily.
The development workflow changed with that habit. An AI assistant can see the code, answer in context, make the change, run the checks, and keep going. The developer no longer has to carry the problem into a separate forum and reconstruct the answer inside the repository.
GitHub recorded 986 million commits in 2025, up 25.1% from the year before. That platform-wide number isn't a direct measure of team productivity, especially while GitHub's developer population is growing. It does show how much more software-making activity is moving through the system.
We haven't seen the product side of most teams make a comparable operating shift.
Your team ships a feature on Thursday afternoon. The deployment is green, and engineering moves to the next issue. Someone still has to update the roadmap, close the feedback that shaped the feature, brief support, write the announcement, refresh the help docs, decide who needs a checklist or tour, and check whether anyone adopts it.
That work determines whether the feature creates value. It also tends to live in different tools, with the product manager carrying the context between them.
We have watched agents change the pace of our own software development. They can understand a large codebase, make changes, run checks, learn from failures, and keep going. Product teams need the same kind of working environment around the customer journey.
That is what we mean by an AI product growth operating system: one connected place where an agent can understand what changed, who it affects, what customers have said, what they do next, and which action should follow.
Why development was ready for agents
Software development was unusually ready for agents. The repository holds years of context. Tests provide a return signal. Version control records every change, and the tools needed to inspect or modify the product are available in the same environment.
The gains are already visible. In a controlled study of 95 professional developers, GitHub found that developers using Copilot completed a defined JavaScript task 55% faster. That result covers one bounded task rather than an entire development cycle, but it shows what happens when AI has useful context and a clear way to check its work.
Agents are also doing more than suggesting the next line of code. Anthropic's analysis of 500,000 coding interactions found that 79% of Claude Code conversations showed automation patterns, compared with 49% in its general chat product.
The product side of the company rarely gives an agent comparable working conditions. The customer history is in support. Usage is in analytics. Requests are in a feedback board. Release context is in GitHub or Linear. The latest decision may exist only in a call recording or the PM's head.
Add a general AI assistant to that setup and you will create documents faster. The handoffs remain.
Product work begins after the deploy
Customers don't experience a pull request. They experience the moment they discover a change, understand it, try it, and decide whether it belongs in their workflow.
Each release creates a trail of product work around that experience:
- The support team needs to know what changed and which questions to expect.
- Customers who requested the feature deserve an update.
- The roadmap and changelog need an accurate status.
- Help content, onboarding, and checklists may need to change.
- Analytics needs to show whether the intended users found and adopted it.
- Feedback and surveys need to capture what usage data cannot explain.
Faster engineering increases the volume of this work. A team that moves from two meaningful releases a month to eight now has four times as many opportunities for the message, targeting, documentation, or measurement to fall behind.
That gap is expensive. Features look underused because the right customers never found them. Support answers from stale docs. The roadmap says "In progress" after the work shipped. A PM enters the next planning meeting with a dashboard in one tab and a pile of disconnected comments in another.
A product agent needs operating context
A prompt can help write release notes. An agent can stay with the workflow.
It can retrieve the evidence behind a decision, preserve the history, prepare or perform approved actions, and return later to check the outcome. That combination turns AI from a writing shortcut into useful product capacity.
The agent needs connected product data to do that well. Here is what each layer contributes:
| Connected layer | Context the agent gains | Work it can prepare or carry out |
|---|---|---|
| Support and feedback | The customer's words, account, urgency, and related requests | Cluster themes, route issues, draft follow-ups, and connect recurring problems to product work |
| Analytics and surveys | What users did, where they stopped, and how they described the experience | Find affected segments, compare behavior, and prepare a targeted experiment or follow-up survey |
| Roadmap and release history | What the team decided, why it mattered, and what has shipped | Keep status current, connect requests to decisions, and preserve the reasoning for the next review |
| Announcements, help docs, tours, and checklists | How the product currently explains and teaches the feature | Prepare consistent updates for each audience and identify guidance that has gone stale |
Connection changes the quality of the work. Feedback alone can tell you that customers dislike an onboarding step. Analytics can show where they leave. Support adds the questions they asked before leaving, while surveys capture the reason in their own words.
An agent can assemble those layers into a useful brief in minutes. The PM spends that time deciding which problem deserves attention.
One release, one continuous loop
Imagine your team has redesigned a billing workflow after months of requests from account admins.
Before launch, the agent gathers the linked feedback, support conversations, roadmap decision, affected segment, and current adoption baseline. The PM reviews the release goal and confirms the audience.
At launch, the same context becomes a changelog entry, a roadmap update, a help article revision, an internal support brief, and targeted onboarding for admins. The agent prepares the work and routes customer-facing claims for approval. Where permissions allow, it can publish the approved items and record what happened.
After launch, the system watches the billing funnel for the affected segment. It can ask admins about a confusing step, connect their replies to earlier requests, and flag support conversations that suggest the redesign missed an edge case.
At the next review, the PM receives the complete thread: why the team shipped the change, who encountered it, what they did, what they said, and which follow-up has the strongest evidence. The decision and its result stay connected instead of being reconstructed from memory.
This is a better use of AI than producing a polished PRD on demand. The agent has a job to follow, access to the relevant layers, permissioned actions, and a result it can observe.
It also closes a loop that product teams routinely leave open. Customers who asked for the feature hear when it ships. Support patterns become structured feedback. A weak adoption result creates a new experiment. The roadmap reflects what the team learned.
The product manager keeps the judgment
We use the phrase "AI product manager" carefully. AI can carry a surprising amount of product operations, including recurring work that teams skip when release pressure rises. Product leadership still needs a person who understands the market, the company, and the promises made to customers.
The division of work should be explicit:
| The agent handles | The product manager owns |
|---|---|
| Retrieving, joining, and summarizing product evidence | Choosing the outcome and deciding which problem deserves attention |
| Drafting, routing, updating, and scheduling repeatable work | Approving customer promises and making tradeoffs |
| Maintaining workflow state across releases and customer signals | Handling exceptions, ambiguity, and sensitive relationships |
| Monitoring agreed metrics and preparing the next review | Interpreting the result and changing product direction |
Newer research on agentic coding points to a similar split. In an analysis of roughly 400,000 Claude Code sessions, Anthropic found that people made most planning decisions while the agent made most execution decisions. Domain expertise improved the quality of the work rather than becoming irrelevant.
We expect the same pattern in product teams. A strong PM with a connected agent can cover more ground, arrive at decisions with better context, and keep the routine parts of the loop moving. The PM remains accountable for the call.
Why we built the partnership
Userorbit already connects the layers around product adoption: support, analytics, feedback, surveys, roadmaps, announcements, changelogs, help content, tours, and checklists.
Our Embedded Product Growth Partnership adds a product manager who installs and runs the workflows with your team. During the first 90 days, we choose one onboarding, activation, adoption, or retention constraint, establish the baseline, connect the evidence, and put live workflows around it.
The work continues after that foundation. The embedded PM reviews results, improves the workflows, and works alongside your existing team or an incoming growth hire. AI handles repeatable analysis and coordination under clear permissions. The PM owns the decisions and the operating cadence.
The aim is practical: help product adoption and learning catch up with the new speed of software creation.
Run one release through this test
Choose a feature your team shipped in the last month. Then check the trail it left behind:
- Could support see the approved context without asking the PM?
- Did the customers who requested it receive a useful update?
- Did the roadmap, changelog, docs, and onboarding reflect the same release story?
- Could you connect adoption data with relevant feedback and survey responses?
- Did one person review the result against the original goal?
- Did that evidence change a follow-up, experiment, or roadmap decision?
Every missing answer points to a manual handoff or a broken return path. Pick one and connect it before adding another AI writing tool.
Software will keep getting easier to produce. The teams that turn that speed into growth will be the ones that help customers absorb what ships and bring the evidence back into the next decision.
