Executive Overview
In the fast-evolving landscape of enterprise software, few leaders face the structural complexities that Sherif Mansour navigates daily. As a 17-year veteran at Atlassian, Mansour oversees artificial intelligence across a sprawling product portfolio that includes more than 20 distinct applications—ranging from legacy systems built over a decade ago to six greenfield applications conceptualized entirely within the generative AI era. Managing 450 product managers (PMs) gives him a unique vantage point on how large technology organizations must adapt, break molds, and reinvent themselves. Today, more than 5 million users regularly interact with Atlassian’s portfolio specifically for its AI capabilities.
At the recent SaaStr Annual event, Mansour’s masterclass addressed a foundational dilemma keeping enterprise founders and product leaders awake at night: the stark polarization of AI integration strategies. For every expert advocating for a headless, chat-centric architecture because "chat is the only interface you need," another insists that conversational UX is inherently flawed and demands dedicated native features. For every voice screaming never to bolt AI onto legacy software—and to rebuild entirely from scratch—there is an opposing argument about speed, agility, and leveraging existing assets.
Rather than choosing sides in the abstract, Atlassian tested these conflicting dogmas at massive scale across real teams and active user bases. The organization confronted three critical product and operational decisions: whether to implement conversational chat interfaces, how to evolve existing workflow engines rather than building entirely new ones from the ground up, and whether the "AI builder" paradigm could completely collapse traditional role boundaries across engineering, design, and product management.
This report provides an in-depth look at Atlassian’s empirical findings, exposing the missteps, the unexpected successes, and the hard-earned organizational truths of scaling AI within a mature enterprise software giant.
Detailed Chronology: Atlassian’s Three Defining AI Decisions
Decision 1: The Chat Interface Dilemma and the "DOS Analogy"
Two years ago, introducing the Rovo chat interface into flagship products like Jira and Confluence was a fiercely debated topic internally.
- The Case Against Chat: Internal detractors argued that chat was merely a transitional stepping stone rather than a definitive end state. For complex, structured tasks—such as filling out multi-field forms or managing intricate data schemas—chat often serves as the most cumbersome interface imaginable. Critics questioned the long-term utility of conversational prompts when structured graphical user interfaces (GUIs) offer precision and visual feedback.
- The Case For Chat: Proponents argued that customer intent in the early days of generative AI was an unknown variable. Because no one could reliably predict what users would attempt to accomplish with artificial intelligence, the safest approach was to provide an open-ended conversational canvas and observe user behavior directly.
Ultimately, the debate was settled by a pragmatic infrastructure requirement. Atlassian had to build a robust chat backend anyway to power underlying AI features across its broad product portfolio. Once that backend infrastructure existed, shipping a conversational interface across more than 20 applications became an effective telemetry mechanism to gather data on actual user intent.
Mansour contextualizes this through an analogy to the early days of personal computing: MS-DOS. The command line served as the universal, generalized interface to the operating system. Users executed spreadsheets, word processors, and utilities all within a text-based environment. Over time, as common use cases crystallized, those functions migrated into dedicated, purpose-built applications with specialized graphic user interfaces. Crucially, the command line never completely disappeared; it remained the flexible safety net handling the long tail of edge cases and custom tasks.
Chat plays an identical role in the modern AI stack. It absorbs unlimited, unstructured use cases while simultaneously surfacing the specific workflows that deserve dedicated, purpose-built interfaces.
From Whiteboard Prompts to Structured Capabilities
To illustrate this evolution, Mansour pointed to Confluence whiteboards. By analyzing what users naturally typed into open-ended AI prompts, Atlassian’s product teams identified recurring behavioral patterns. One unexpected architectural realization quickly emerged: every single feature built to assist human users in a whiteboard environment also had to be exposed as a programmatic tool for autonomous agents.
For instance, a capability like "group-into-themes" evolved from a simple user-facing prompt into a core skill that Rovo agents could invoke programmatically. Similarly, "whiteboard-to-backlog" transformations became standard agentic tools. By supporting protocols like the Model Context Protocol (MCP) and Atlassian’s own command-line interface, customers could tap into these specialized skills from external development environments—including tools like Claude Code and Cursor. Consequently, Atlassian’s proprietary product features deliver value whether the end user is sitting inside a native Atlassian application or operating externally.
Initial assumptions posited that chat interfaces would be strictly temporary training wheels—to be discarded once customers matured and migrated permanently to standalone tools like ChatGPT or Claude Code. That assumption proved false. Millions of users continue to rely on Rovo chat daily. Qualitative customer interviews revealed a nuanced reality: professionals use whichever AI interface sits closest to their active workspace. Just as Mansour utilized Google Slides and Gemini to lay out his presentation decks because they were immediately at hand, enterprise users engage with the AI native to their current context.
Key Takeaway: If your software product attracts daily active users, ship conversational chat. Use real-world telemetry on what users type to inform your product roadmap and determine exactly when—and what—to build next.
Decision 2: Bolting AI onto Legacy Workflows (The Jira Case Study)
The prevailing doctrine in modern software engineering preaches a strict gospel: never bolt AI onto an existing legacy product; always reimagine and build from scratch. Atlassian actively violated this cardinal rule.
To understand why, one must look at the true nature of Jira. New product managers joining Atlassian often arrive with the preconceived notion that Jira is exclusively a tool for software developers. In practice, however, the vast majority of Jira users are not software engineers. Jira functions fundamentally as a flexible, generalized workflow engine deployed across an astonishing variety of enterprise teams. Mansour highlighted everyday use cases far removed from code repositories: processing consumer complaints within a rideshare application or managing complex dispute workflows for a major telecommunications provider.
Two and a half years ago, rather than spinning up a greenfield project, Atlassian took its existing Jira automation designer and inserted a single, discrete operational box: invoke a Rovo agent at this specific step in the sequence. It was a literal, unvarnished bolt-on to a mature, established workflow engine, executed rapidly simply because leadership wanted to learn at the speed of the market.
Enterprise customers pushed this primitive capability far beyond initial expectations. They began constructing complex branching logic, instituting multi-step conditions, and chaining multiple specialized agents together. One prevalent pattern described by Mansour involves an incoming customer support ticket triggering an automated workflow: an intake agent processes the ticket, a marketing agent calls external APIs like Canva to generate dynamic visual assets, and a social media agent reviews the generated assets before auto-publishing them. These customers leveraged existing human-run workflows already codified in Jira, seamlessly blending automation into familiar operational patterns.
Mansour offers a domestic analogy: purchasing a fixer-upper house and choosing to live within the existing kitchen layout for several months before undertaking a major renovation. Living inside the old space revealed precisely which structural flaws mattered most. Over time, individual cabinets and appliances were swapped out before the entire kitchen was eventually gutted.
For software companies, if you possess an active user base and established operational workflows, that asset base is too valuable to discard. You evolve it iteratively. Building entirely from scratch remains reserved for brand-new, greenfield product concepts—a strategy Atlassian executed concurrently with its six AI-native applications.
The Core Principle: Human Primitives Equal Agent Primitives
Approximately six months into this iterative work, Atlassian’s product organization codified a guiding architectural principle: Any task you can accomplish with a human teammate, you should be able to accomplish with an AI agent.
Every complex challenge solved historically for human collaboration—providing operational tools, contextual background, explicit goals, clear accountability, and visibility into peer activities—applies identically to autonomous agents. As enterprises deploy fleets of agents alongside human workers, cross-functional planning and visibility become paramount.
The organizational scale differs, but the foundational primitives are nearly identical. Consequently, Atlassian systematically audited its product portfolio item by item to align human and agentic capabilities. This led to a strict design review rule across the company: whenever a product team demonstrates an agent capability that a human user could not or would not perform natively within the software, reviewers must interrogate the justification. While legitimate architectural reasons occasionally exist, nine times out of ten, Mansour notes, the agent should be forced to follow the exact behavioral patterns already established for human users.
Decision 3: The Limits of the "AI Builder" Paradigm
The software industry has increasingly romanticized the rise of the "AI builder"—an omnicompetent technologist whose primary function is shipping production code rapidly via advanced generative AI tools. A popular narrative suggests this trend will collapse traditional organizational silos, merging product management, design, and engineering into a single hybrid role. Managing 450 PMs and approximately 800 designers, Atlassian sought to test this hypothesis empirically.
The company launched roughly 10 internal software development projects staffed deliberately with hand-picked AI builders: traditional software engineers alongside product managers and designers who possessed the coding capability to leverage AI across both greenfield and legacy codebases.
The initial phase was characterized by blistering momentum. During the first few weeks, these hyper-empowered teams moved at unprecedented speed, shipping features rapidly. However, after several weeks to a few months, the momentum ground to a sudden, dramatic halt.
Mansour describes the operational failure vividly: "Everyone was rowing, but no one was steering."
Because every participant was acting as a tactical builder, nobody retained the bandwidth to make critical strategic calls regarding overarching product direction, prioritization, or architectural vision. The teams began spinning in circles. Ultimately, the PMs and designers voluntarily drifted back to their traditional operational domains. Supplying deep customer context, defining requirements, and making hard trade-off decisions proved to be the most valuable contribution they could make to unblock their engineering counterparts.
Mathematical team ratios explain this structural reality. Atlassian typically maintains a ratio of roughly one PM and designer for every 10 engineers on standard product teams, and one to 20 on platform teams. As generative AI enables engineers to output code at vastly accelerated rates, the effective operational ratio expands to 1:30 or 1:40. Engineers rapidly complete assigned tasks and return immediately demanding clarity on what to build next and whether the current trajectory is strategically sound. A product manager spending their workday "vibe coding" is fundamentally unavailable to provide that strategic steering.
While Atlassian continues to embrace specialized AI builder roles, leadership acknowledges that this cannot represent the default profile for most product managers or designers. In a micro-startup environment, everyone can wear every hat; in a mid-sized or enterprise organization, structured division of labor remains essential.
Supporting Context & Metrics: Flipping the Hiring Pipeline
The structural shifts in product development have forced a parallel evolution in talent acquisition. Executive leadership across the tech sector frequently echoes a common refrain: stop hiring junior personnel; instead, purchase senior productivity amplified by AI tools. The conventional wisdom argues that junior engineers primarily produce low-quality code ("slop"), require extensive onboarding, and take years to deliver positive ROI.
Atlassian deliberately inverted this conventional hiring pipeline. Historically, the company’s R&D intake favored a small base of junior talent balanced by a heavy concentration of mid-level and senior professionals. Today, the pipeline is heavily weighted toward both ends of the experience spectrum—bringing in more junior engineering talent alongside seasoned senior leaders, with fewer mid-level hires in between.
The strategic rationale is rooted in cognitive ergonomics. Atlassian employs thousands of R&D professionals who must systematically unlearn workflows and habits ingrained over 10, 20, or 30 years of professional software development. In practice, unlearning deep-seated behavioral patterns is exponentially harder than learning entirely new paradigms from scratch.
By contrast, modern new graduates carry no legacy muscle memory. Mansour noted that his own 12-year-old child bypassed traditional syntax education entirely, transitioning directly from visual coding blocks to vibe coding applications on Replit—operating under the assumption that conversational natural language is simply what software development is.
Internal Atlassian research strongly validates this pipeline shift:
- Adoption Velocity: Junior developers are up to 38% more likely to integrate AI tooling into their daily workflows, experiment with twice as many distinct tools, and test novel patterns more frequently than their senior counterparts.
- The Quality Gap: While juniors naturally generate higher volumes of unrefined code ("slop") and report feeling less consistently productive due to shifting baselines, senior engineers exhibit slower initial adoption rates. However, seniors excel at quality control, identifying structural flaws, and extracting high-fidelity output from AI models by leveraging decades of architectural experience.
To bridge this gap, Atlassian deliberately pairs the two cohorts through an internal program called AI Builder Week. Every few months, the entire R&D organization pauses regular operational work for a synchronized four-day sprint. Junior engineers lead sessions demonstrating novel AI tools and experimental techniques, while senior engineers lead masterclasses focused on rigorous quality control, slop mitigation, and building deeply differentiated AI capabilities rather than relying on generic wrapper functionalities. Atlassian has open-sourced the program structure, schedules, and training videos for the broader industry.
Future Outlook & Strategic Summary
As generative AI transitions from an experimental novelty to foundational enterprise infrastructure, Atlassian’s empirical findings offer a pragmatic roadmap for software leaders navigating legacy transformation. The era of dogmatic extremes—insisting exclusively on greenfield rebuilds or dismissing conversational interfaces—has given way to a nuanced, hybrid reality.
For product organizations looking ahead, Mansour’s roadmap underscores several foundational imperatives:
- Embrace Conversational Telemetry: Ship chat interfaces where active users reside, utilizing open-ended user behavior as a discovery engine to determine when and how to build dedicated, purpose-built graphical features.
- Iterate on Existing Assets: Do not reflexively discard mature workflow engines; evolve them iteratively by embedding agentic steps where human operations already flow smoothly.
- Maintain Strategic Steering: Resist the urge to collapse all product and design roles into solitary AI builders. High-velocity engineering requires proportional, dedicated strategic oversight to prevent operational drift.
- Balance Institutional Memory with Digital Natives: Restructure hiring pipelines to embrace both unburdened junior talent and seasoned senior architects, fostering cross-generational mentorship to master both speed and quality control.
Ultimately, building successful AI-driven software is not about finding a single silver-bullet architecture; it is about building disciplined, adaptable teams capable of learning faster than the technology evolves beneath them.
