Skip to content

From Org Chart to Product Ownership

AI makes the path from customer problem to impact more continuous.

≈ 10 min readSoftwareAIMethodology

An AI assistant produces a draft – and afterwards the work item waits for approval, review and release just as before. Who carries it from the observed customer problem to measurable impact? No draft generation, however fast, answers this question. AI can make the flow of work from the first customer signal through plan and implementation to review and impact more continuous – if responsibility for problem, decision, review and impact is brought together in one place.

AI doesn’t remove organizational boundaries automatically. It lowers the cost of getting up to speed on the next step. Whether this results in one connected piece of work or merely a faster feed into the same waiting points is decided by the organization, not by the model.

The flow of work from customer problem to impact#

By flow of work I mean a concrete chain here: a customer signal is observed, it leads to a hypothesis, the hypothesis to a plan, the plan to an implementation, the implementation to a review with domain acceptance, then a release and finally an observable impact that flows back as a signal into the next cycle.

flowchart LR
    S[Customer signal] --> H[Hypothesis and plan]
    H --> E[Design and implementation]
    E --> Q[Review and acceptance]
    Q --> R[Release]
    R --> W[Observe impact]
    W --> S
    A[AI: context, variants,<br/>tests and documentation] --> H
    A --> E
    A --> Q

The starting hypothesis is that in organizations built on division of labor, this chain is rarely continuous: one ticket describes the wish, another person decides on the design, a third builds the interface, a fourth checks the release. Each role can do its job very well while the result for the customer still remains incomplete. If you only see a small slice, you can hardly judge whether a new feature solves the customer problem or merely makes a subprocess tidier.

What AI mainly changes about this chain is one cost factor: getting up to speed on the next step. An assistant can explain an unfamiliar service, gather existing decisions, sketch a data flow and suggest suitable tests. It doesn’t replace domain knowledge in the process. It lowers the barrier to bringing in domain knowledge from other parts of the organization in time – before a decision is made, not after a finished solution has been delivered.

Handoffs don’t get shorter automatically#

My thesis is: AI can shorten handoffs if responsibility for problem, decision, review and impact is brought together. This is a hypothesis about organization, not a proven law. If responsibility stays as distributed as before, AI merely speeds up the production of intermediate results that still wait for the same approvals.

The post on faster development and unchanged processes describes this downside: if an organization just fills the same old process faster, the bottleneck moves. More drafts wait for the same reviewers, and more documents contradict each other. The gain only comes when the freed-up time flows into understanding the whole piece of work.

Bringing responsibility together doesn’t mean that one person has to be product manager, designer, security expert and operations lead at the same time. It means that a clearly bounded slice of the product is followed through by the same place: from the observed problem through a hypothesis and a change to feedback from usage. Specialist disciplines remain indispensable. The difference lies in the timing: specialists are brought in earlier and more deliberately instead of receiving a finished solution at the end of a long chain.

The org chart doesn’t disappear because of this. People need clear responsibilities, development prospects and decisions that don’t get lost between teams. But the continuous flow of work can become more important than the boundaries between the boxes – where responsibility actually has been brought together.

Vertical slices as a testable hypothesis#

Vertical work packages make this thesis testable. Instead of breaking a change down by technical layers – first the data model, then the API, then the UI – a small, usable slice is carried through all layers. Such a slice has a clear purpose, a visible impact and a manageable number of open decisions.

This way of working made sense even without generative AI. One possible obstacle was the effort of getting into unfamiliar parts of the system: a developer knew the frontend, say, but not the rules in the backend. The product team knew the impact for users, not the consequences for operations or the data model. So work packages were cut along responsibilities and then pieced back together over many meetings.

flowchart TD
    P[Product problem] --> V[Vertical slice]
    V --> U[UI]
    V --> F[Domain logic]
    V --> D[Data and contracts]
    V --> B[Operations and observation]
    U --> X[One verifiable result]
    F --> X
    D --> X
    B --> X
    K[AI: make dependencies and<br/>suggestions visible] --> V

Smaller vertical slices are a testable organizational hypothesis, not a blanket statement about every team. The hypothesis is that a team with AI support can explore more of this context on its own – which services are affected, which contracts change, which test cases are missing, which documentation needs to be updated. Whether the observations in a concrete context support this hypothesis can be checked using waiting time, number of handoffs, rework and time to user feedback. The values are collected with identical definitions before and after a limited pilot; other process changes have to be recorded, because such a comparison doesn’t prove a clear cause. If the measurement turns out differently than expected, the hypothesis is not confirmed for this context for now – the team hasn’t failed.

A vertical slice must not become a pretext for offloading every specialist discipline onto a few people. Where security, regulation or deep domain knowledge are needed, collaboration remains mandatory. The slice changes the order of involvement, not its necessity.

Technology becomes an option again#

Many technology choices arise from what a team happens to know. That’s understandable: an unfamiliar platform demands research, small experiments and the worry of being left alone with it later. That’s why requirements are sometimes adapted to the existing tools, even though a different path might fit better.

AI changes this calculation. It can search documentation, explain examples from a repository, compare variants and prepare a small prototype. That alone doesn’t turn an unfamiliar technology into a good decision. But it becomes cheaper to make the decision based on a real experiment instead of habit.

A useful investigation keeps several possibilities open:

  • What is the smallest change with which we learn something about the customer problem?
  • Which existing systems, data and contracts do we really need to understand?
  • Which assumption does the AI make, and how can it be checked?
  • What impact do we expect after the release, and how would we notice the opposite?

The answers don’t always have to be documented like an architecture decision. For a small change, a clean pull request with tests and a short rationale is often enough. What matters is that the AI doesn’t just produce more options but helps evaluate options faster and discard bad ideas earlier.

Creating gets cheaper, review and acceptance become more important#

The most visible result of AI is often a draft: code, a test, a summary, an API description, a release note. The draft can be surprisingly good. But it can also carry a false premise forward with great conviction. The cheaper creating becomes, the more the value of review and domain acceptance grows.

Review here means more than the pull request. It includes the domain check of a requirement, the look at contradictions in existing knowledge, the test under realistic conditions and the question of whether the release improves the product. Quality assurance is therefore not a last gate before rollout. It accompanies the entire slice.

review_focus:
  product_question: "Does this solve the observed customer problem?"
  domain_question: "Which business rule could make this wrong?"
  technical_question: "Which contract or dependency can break?"
  quality_signal: "What evidence would change our decision?"
  release_check: "Can we observe the result and recover safely?"

This example is not a new checklist for every little thing. It shows the shift: with AI-assisted drafts, the bottleneck can move from generation to review. What then becomes more important is deciding quickly and reliably what to keep, change or discard from a draft.

The NBER study “Generative AI at Work” provides a limited empirical hint on this. Among more than 5,000 customer support agents, an AI assistant increased the number of cases resolved per hour by 14 percent on average, with less experienced workers benefiting in particular. I read this finding about the less experienced workers as a hint that AI can spread proven practices – that is my interpretation, not a direct finding of the study. In any case, the study is not evidence of the same effect in every task, let alone in product development. What remains for product work is mainly this: the first draft becomes more accessible. That doesn’t devalue experience. Experience becomes more visible where it counts – in choosing a direction, in recognizing an atypical case and in judging quality.

Anchoring responsibility technically#

If this thesis is meant seriously – responsibility for problem, decision, review and impact brought together – then it also has to be reflected in the systems through which work flows. Otherwise it remains a good intention. Two examples show what such anchoring can look like.

A request control layer can route HTTP, MCP, A2A, webhooks and chat into the same planning path and bind execution to explicit task authority, budgets, contracts, evidence and review. That is the technical form of this bundling of responsibility: no matter which channel a request arrives through, it goes through the same planning, and execution is bound to explicit authority.

A workflow engine can model recurring work across several systems as an approved, logged workflow and hold back steps with external effects until confirmation. Here too, the design separates preparation and execution from the confirmed external effect: a piece of work may be prepared, checked and repeated, but the step that has an external effect waits for acceptance.

Transferring this to the organization is a hypothesis, not a guarantee. If knowledge can be found, if releases are prepared so that a team can follow a change in a controlled way all the way to its impact, and if product and service information comes from the same verified sources instead of aging in separate copies – then one piece of work can close more gaps at once: a product change delivers test cases, operational information and a draft of the customer documentation at the same time. Recurring support questions show early which product rule or explanation is missing. Errors and follow-up questions flow back into rules, tests and later work packages. Whether these conditions are met, every organization has to check against its own flow of work.

One complete slice as a test#

The change doesn’t start with a new org chart. It starts with a real, limited product problem. A team takes a piece of work that has several handoffs today and carries it through completely once: understand the customer question, check the assumption, build the change, assess quality, release and look at the impact.

vertical_slice:
  customer_problem: "Describe the observed problem"
  smallest_change: "Deliver one useful outcome"
  ai_support:
    - "Find relevant context"
    - "Prepare tests and documentation"
  human_review:
    - "Validate domain assumptions"
    - "Accept quality and release risk"
  outcome_signal: "Measure customer use and failures"

After that, the discussion about roles and structure becomes more concrete. Perhaps it turns out that a team can own an interface itself. Possibly a shared source of knowledge is missing. Or a specialist remains a permanent part of the process. What matters is that the organization learns from observed work and not from an abstract restructuring plan – and that it discards the hypothesis where the measurement speaks against it.

AI doesn’t make end-to-end product development easy. It makes it possible more often where responsibility, review and impact belong together and aren’t spread across many stations. Research, drafting, tests, documentation and release preparation move closer together. The org chart stays. But the decision every organization can make now is concrete: take ownership of one selected, limited flow of work end to end once, and measure by its impact whether the hypothesis holds.

Further reading#

Revised and translated from German with the help of AI.