I've been a designer, a front-end engineer, and now a product leader. I've sat in every seat of what I think of as the triad: the relationship between design, engineering, and product that makes software happen.
I'm watching it come apart. Not because people stopped caring, but because AI handed everyone a set of capabilities that used to belong to someone else, and nobody figured out how the team is supposed to work now.
The triad
The way it used to work: Product figured out what to build and why. Design figured out how it should look and feel. Engineering figured out how to make it real. Each role had a lane, a set of tools, and a handoff point. Product wrote specs. Design made mockups in Figma. Engineering wrote code. The artifacts moved in one direction: idea to mockup to code to production.
It wasn't perfect. The handoffs were lossy. Engineers built things that didn't match the mockup. Designers specced interactions that were expensive to implement. PMs changed requirements mid-sprint. We all complained about it constantly. But we understood the system. Everybody knew their role, knew where to look, and knew whose turn it was.
Fullstory lived downstream of all of this. After the triad finished its work and the code hit production, Fullstory showed everyone what actually happened. What real users actually experienced, not what the spec said should happen or the mockup promised. Session replay became the shared visual truth that connected support and sales and product and engineering. The one place where everyone on the team was looking at the same thing.
The disruption nobody talks about
The AI conversation in public has been about speed. How fast can agents write code? How many PRs can you ship in a day? How do you 10x your output? That's the story on Twitter and at conferences and in pitch decks.
The story inside companies is different. It's emotional and it's messy, and nobody quite knows how to talk about it yet.
A designer on your team opens Claude Code and starts building a feature directly. The code works, mostly, but it doesn't follow the component library and the CSS is inline and the accessibility is wrong. It goes into a PR. An engineer reviews it, rewrites half of it, and feels like they're cleaning up after someone who shouldn't have been coding.
An engineer uses an AI agent to redesign a settings page. The agent one-shots it. The layout is functional but the spacing is off, the hierarchy is flat, and it doesn't match the design system. The designer sees it in staging and feels bypassed. Nobody asked them. Nobody even showed them.
A PM is hacking a prototype in Cursor to prove out a concept. It's impressive for a demo but it's held together with duct tape, and now the CEO saw it and thinks it's the real thing. Engineering has to rebuild it properly and explain why it takes longer the second time.
And the agents are the worst offenders. They generate code, create a PR, and move on. No stopping to check whether the experience makes sense. One-shot and ship.
Everyone can build now. But everyone's building alone.
What got lost
The triad had friction, but it also had forced alignment. The Figma handoff meant a designer and an engineer had to look at the same mockup and agree on what they were building. The spec review meant product and engineering had to negotiate scope in the same room. The QA cycle meant someone was actually using the thing before it shipped.
AI removed the friction. But it also removed the alignment.
When a designer can go straight to code, there's no handoff conversation. When an engineer can generate UI without a mockup, there's no design review. When an agent writes a feature in ten minutes, there's no moment where the team stops and asks: does this actually do what we want? Does it look right? Does the experience make sense?
The artifacts that used to force collaboration (the Figma file, the spec doc, the staging environment) still exist, but they're increasingly optional. People skip them because they can. The agent certainly skips them.
The result is a PR backlog full of AI-generated code that nobody has properly reviewed for UX quality. Engineers are reviewing code, checking for logic bugs and security issues and performance problems. But nobody is systematically reviewing what users will actually see. Does the button look right? Does the flow make sense? Did the agent put the error message in a place where someone will actually notice it?
Code review checks the code. Nobody checks the experience.
The session replay insight
I keep coming back to why Fullstory's session replay worked as well as it did. The obvious answer is that it showed you what users do. But the deeper answer is that it gave the whole team a shared surface.
Before session replay, every team had their own version of reality. Support had ticket descriptions. Product had analytics dashboards. Engineering had error logs. Sales had customer quotes from memory. Everyone was describing the same product experience through different lenses, and half the arguments in cross-functional meetings were really just arguments about whose version of reality was correct.
Session replay collapsed all of that into one visual artifact. You press play. You watch what happened. The support rep, the PM, the engineer, and the designer are all seeing the same 30 seconds of a user struggling with a checkout flow. No translation layer. No telephone game.
Teams build better when they're looking at the same thing.
Not the same dashboard or the same Jira ticket. The same visual experience. That's the thing Fullstory got right, and I think we underestimated how transferable that idea is.
A new shared surface
AI broke the triad, and no amount of process is going to reassemble it the way it was. Designers are going to keep coding. Engineers are going to keep making product decisions. PMs are going to keep hacking prototypes. Agents are going to keep one-shotting features. That genie is out.
What's missing isn't the old workflow. It's a shared surface for the new one.
Think about what would have to be true for this blurry new triad to actually work. You'd need a place where a PM can describe what they want and see it take shape visually. Where a designer can review what the agent built and annotate the experience, not the code. Where an engineer can see the full context of what's being asked for and why. Where an agent can get visual feedback and iterate with the humans who care about the outcome, instead of one-shotting into a PR and hoping for the best.
That surface isn't Figma, which gives you static mockups of something that doesn't exist yet. It isn't GitHub, where you're reading diffs nobody can evaluate visually. And it isn't Slack, where people describe visual problems in text. The collaboration layer needs to be the product experience itself. The running, interactive, visual thing.
Session replay is already that for production. The same concept works upstream.
I've been working on this at Fullstory. We're calling it Subtext. The product experience becomes the shared surface where the whole team works. An agent builds something and the result is a replayable session that anyone can watch and comment on. A designer sees a spacing problem and their feedback goes back to the agent as structured visual context, not a Slack message. A PM reviews the experience the way a user would, not through a code diff.
It's early. We're testing with a handful of teams. But the conviction comes from watching session replay do this same thing for a decade on the production side. Collapse everyone's separate version of reality into one shared visual truth. The build process needs that just as badly, maybe more, now that AI has everybody building at once.
Why "again"
The triad wasn't just a process. It was a way for different kinds of thinkers to contribute to the same product. The designer who sees spatial relationships and hierarchy. The engineer who sees system constraints and edge cases. The PM who sees user needs and market context. The best software I've ever shipped came from those perspectives colliding, not from any single person or agent doing it all alone, no matter how fast.
AI made everyone capable of building. What it didn't do is give them a reason to look at the same screen. That's the part we're working on.
We built Fullstory to help teams see what users experience after something ships. We're building Subtext to help teams see what they're building while they build it. Same idea. Earlier in the process. More people in the room.
That's what "build together again" means. Not going back. Going forward with the thing that actually made the old way work, a shared surface where everyone sees the same product experience, and bringing it into a world where everyone has superpowers and nobody has a process.