Atlassian, Entire Chiefs See Coding Agents Shrink Engineering Management

Building world-class engineering teams in the age of AI - The Pragmatic Summit — The Pragmatic Engineer

The Pragmatic Engineer

Autonomous developer agents eliminate code review bottlenecks while forcing companies to flatten management layers and cap runaway token budgets.

AI-assisted summary of Building world-class engineering teams in the age of AI - The Pragmatic Summit — original source. Check the original for full context.

Source published:

Key ideas

  • Atlassian has deployed its internal coding agent, Robo Dev, to 100% of its engineering staff, driving an 89% increase in pull request velocity, a 42% decrease in cycle time, and automated detection of 51% of vulnerabilities prior to production. (27:14)
  • Software development workflows are migrating from manual line-by-line code review to boundary validation, where human engineers focus on defining guardrails and verifying system inputs and outputs. (12:57)
  • Disciplinary boundaries across the SDLC are collapsing as product managers and designers use coding agents to ship working interactive prototypes, shifting roles toward 'product engineers' and 'design engineers.' (16:32)
  • Engineering leaders face a budgetary inversion as fixed headcount OpEx gives way to variable token expenses, forcing organizations to navigate trade-offs between uncapping developer productivity and managing surging compute costs. (29:43)

Detailed notes

## Background Published on YouTube by The Pragmatic Engineer on February 24, 2026, this panel from The Pragmatic Summit features Thomas Dohmke (co-founder and CEO of Entire, former CEO of GitHub) and Rajeev Rajan (CTO of Atlassian). According to the description, the session explores what it takes to build world-class engineering teams in the age of AI, serving as a companion to an in-depth Pragmatic Engineer newsletter deep dive.

## TL;DR Thomas Dohmke and Rajeev Rajan dissect how AI-native development is upending traditional software engineering, shifting developers from manual syntax generation to agent orchestration and verification. They explore how coding agents are breaking down the silos separating product managers, designers, and engineers into unified builder roles, while warning against pull request bottlenecks and uncurated feature bloat. The discussion also examines organizational realities: management hierarchies are flattening as leaders return to hands-on coding, engineering budgets face variable token costs instead of static headcount OpEx, and distributed teams rely on agents as round-the-clock sparring partners. Ultimately, both leaders emphasize that beyond enterprise efficiency metrics, AI's greatest victory is stripping away tooling friction and returning the pure creative joy to software development.

## Atmosphere & style The panel is refreshingly candid, collegiate, and pragmatic, punctuated by playful banter about poaching talent, corporate IT constraints, and enterprise bureaucracy. Gergely Orosz moderates with an insider's technical depth, giving both speakers room to contrast early-stage startup agility with large-scale enterprise execution. Rather than indulging in ungrounded marketing hype, the conversation pairs frank skepticism toward corporate dogma with an infectious, nostalgic enthusiasm for tinkering, leaving listeners with an energized sense that programming has become fun again.

## Bulletin - [27:14](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1634s) Atlassian has deployed its internal coding agent, Robo Dev, to 100% of its engineering staff, driving an 89% increase in pull request velocity, a 42% decrease in cycle time, and automated detection of 51% of vulnerabilities prior to production. - [12:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=777s) Software development workflows are migrating from manual line-by-line code review to boundary validation, where human engineers focus on defining guardrails and verifying system inputs and outputs. - [16:32](https://www.youtube.com/watch?v=fYh1CWadxDM&t=992s) Disciplinary boundaries across the SDLC are collapsing as product managers and designers use coding agents to ship working interactive prototypes, shifting roles toward 'product engineers' and 'design engineers.' - [29:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1783s) Engineering leaders face a budgetary inversion as fixed headcount OpEx gives way to variable token expenses, forcing organizations to navigate trade-offs between uncapping developer productivity and managing surging compute costs.

## Key takeaways - [00:05](https://www.youtube.com/watch?v=fYh1CWadxDM&t=5s) Being AI-native represents a cultural and operational mindset shift toward agent orchestration rather than a strategy primarily aimed at reducing engineering headcount. - [02:33](https://www.youtube.com/watch?v=fYh1CWadxDM&t=153s) Natural-language markdown specifications are unlikely to replace standard programming languages for large-scale coordination, as programming languages provide an essential, unambiguous cross-border vocabulary. - [05:08](https://www.youtube.com/watch?v=fYh1CWadxDM&t=308s) Because raw code implementation is becoming commoditized, software development friction is moving to the 'left of code' (intent and spec formulation) and the 'right of code' (CI/CD, deployment validation, and incident triage). - [08:35](https://www.youtube.com/watch?v=fYh1CWadxDM&t=515s) Agent performance depends heavily on proprietary environmental context, as demonstrated by Atlassian's Teamwork Graph outperforming generic models by mapping cross-tool collaborator relationships. - [09:01](https://www.youtube.com/watch?v=fYh1CWadxDM&t=541s) AI coding and review agents serve as on-demand technical sparring partners, helping distributed and remote teams eliminate asynchronous handoff delays across time zones. - [12:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=777s) The operational source of truth in development is moving upstream to requirements, discussions, and video walkthroughs documented in tools like Confluence, Jira, and Loom. - [12:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=777s) Zero-manual-code paradigms deliver rapid productivity gains in clean greenfield repositories, but autonomous agents continue to face substantial friction in complex, tightly coupled legacy codebases. - [15:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=943s) Feeding unconstrained backlogs directly into coding agents risks shifting bottlenecks into pull request review fatigue, potentially producing bloated software without disciplined architectural curation. - [16:32](https://www.youtube.com/watch?v=fYh1CWadxDM&t=992s) Role convergence is accelerating across tech organizations, prompting non-engineers in marketing, comms, and design to build bespoke software tools via modern workspace agents. - [18:27](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1107s) AI agents enable engineering executives to rapidly write and ship code again, facilitating flatter corporate hierarchies and wider spans of control that reduce middle-management layers. - [20:29](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1229s) Engineering career tracks are increasingly favoring hands-on builders who master agent orchestration over traditional bureaucratic personnel managers. - [21:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1317s) Unlike historical bottom-up developer adoption patterns, enterprise deployment of coding agents is frequently being driven by top-down executive mandates from CTOs and CIOs. - [24:01](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1441s) Because generative AI can automate and dissect corporate bureaucracy, engineering managers must replace generic, AI-assisted performance feedback with transparent, direct communication. - [27:14](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1634s) Long-term projections indicate that developers may move away from IDEs and conventional languages entirely, translating high-level intent directly into underlying execution runtimes or 'AI JVMs.' - [29:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1783s) The rapid adoption of autonomous agents is forcing corporate finance to adapt from static payroll budgets to consumption-based token forecasting. - [32:50](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1970s) By eliminating tedious configuration overhead, build failures, and package setup, AI tools collapse the gap between conceptual inspiration and working software, restoring the core enjoyment of programming.

## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=fYh1CWadxDM&t=5s) Framing the AI-Native Engineering Team

Opening the Pragmatic Summit discussion, Gergely Orosz remarks on how fast the technology landscape has moved: when organizing the event five months prior, the team expected AI to merely be part of the agenda, but it quickly became evident that AI is everywhere. Introducing the panel, Gergely points out the common ground shared by Thomas Dohmke (co-founder and CEO of Entire, former CEO of GitHub) and Rajeev Rajan (CTO of Atlassian). Both have built and led massive engineering organizations that create beloved developer tools. Yet Thomas is now operating at the opposite end of the spectrum, bootstrapping a brand-new startup. Gergely poses the foundational question: what does an "AI-first" or "AI-native" team actually mean?

```mermaid flowchart LR accTitle: The Expanding Impact of AI on the Software Development Life Cycle accDescr: Diagram tracing how AI shifts work across planning, implementation, and operations. subgraph Left ["Left of Code (Ideation & Planning)"] Spec["Intent & Spec Writing<br/>(e.g., Confluence comments)"] end subgraph Middle ["Code Implementation"] Agents["Coding Agents<br/>(Engineers write zero lines)"] end subgraph Right ["Right of Code (Ops & Delivery)"] Delivery["CI/CD, Deployments,<br/>Incident & SEV Resolution"] end Spec --> Agents Agents --> Delivery ```

Rajeev Rajan explains that being AI-native is fundamentally a mindset shift around embracing agents and orchestration. While Atlassian still maintains traditional teams managing legacy architectures, several internal teams have become fully AI-native. In those groups, engineers write zero lines of code; instead, their day-to-day work centers on orchestrating agents. Crucially, the boundaries separating product managers, designers, and software engineers are dissolving. PMs and designers are generating code directly, shrinking the handoff distance between disciplines, unlocking far more vigorous debates, and driving 2x to 5x productivity gains without necessarily shrinking team headcount. In Rajeev's eyes, the popular industry narrative that AI exists primarily to downsize teams misses the true paradigm shift:

> “I find that the discussion about using AI to produce more efficiency and maybe smaller teams and fewer engineers is missing the point. It's more about what can you create now with AI that you could not create before.” — Rajeev Rajan

[02:33](https://www.youtube.com/watch?v=fYh1CWadxDM&t=153s) The Illusion of Daily Automation and the Natural Language Dilemma

Thomas Dohmke offers a complementary, grounded perspective, drawing a historical parallel to the phrase "cloud native." When GitHub was founded in 2008, nobody used that term; it was coined retroactively once the industry observed how architectures had fundamentally changed. What the industry labels "AI native" today will look radically different in just a few years. Thomas illustrates true AI nativity through his two sons, ages 13 and 11, who spend their time playing Minecraft, occasionally coding, and casually using Adobe Firefly to generate puppy wallpapers for their phones simply because "everybody in school is using it." For their generation, defaulting to an AI agent will replace the instinctive Google search.

At the same time, Thomas calls out the exaggerated hype circulating across podcasts and social media claiming that startup life is already fully automated by agents. In reality, modern founders still drown in manual overhead: dealing with HR platforms, processing month-end book closes, filing director and officer insurance questionnaires, and triaging hundreds of inbound angel investment requests or unsolicited job pitches after public launch announcements. No agent handles those gritty, bureaucratic chores yet.

Furthermore, Thomas critiques the utopian vision of coordinating massive organizations via natural-language specifications:

> “Yes, we're going to use cloud code or or some agent to build code, but no, we're not going to feed markdown files into that like 3,000 software engineers all collaborating on markdown. That is a nightmare, right?” — Thomas Dohmke

- Standard programming languages act as an equalizer: they constrain team communication to roughly 20 rigid keywords that everyone can agree upon across global distributed teams. - Forcing engineers in Germany, Spain, India, or China to articulate nuanced system architecture and edge-case specs in non-native English markdown creates steep communication barriers that the industry has not yet solved.

[05:07](https://www.youtube.com/watch?v=fYh1CWadxDM&t=307s) Looking at Less Code and the AI-Native SDLC

Turning to concrete workflows, Thomas notes that engineers writing greenfield code today intentionally force themselves to avoid reading source code line-by-line. Instead, they drive the process through prompts, intent formulation, and reasoning engines. A lighthearted banter unfolds when Thomas mentions interviewing candidates from Microsoft, GitHub, Atlassian, ThoughtWorks, and Block—prompting Rajeev to warn him to go easy on poaching Atlassian talent. Thomas laughs, explaining that about a third of the team at Entire is Australian because one of his co-founders went to high school with him in East Berlin before emigrating to Australia. He jokes that the Australian press seized upon the Entire launch to poke fun at Atlassian's recent stock movements, though the two events had nothing to do with each other.

Returning to engineering practices, Thomas argues that manually reviewing code line-by-line will become an unsustainable bottleneck. High-performing developers are already relying on tools like Cursor Bugfinder to highlight mistakes, paving the way for coding agents to resolve issues directly with review agents without requiring a human middleman:

> “And that is a skill in itself and that's I think answering the question, are we going to replace humans with agents? No, we're up-leveling the humans to become the the masters of these of these agents.” — Thomas Dohmke

Rajeev elaborates that because coding and implementation are becoming nearly free, the real friction points have migrated to what he terms the "left of code" and the "right of code": - **Left of Code:** Specifying and planning intent before implementation. At Atlassian, product-oriented engineers collaborate inside Confluence; agents consume those functional comments and work in autonomous routing loops to solve tasks. - **Right of Code:** Post-implementation workflows spanning CI/CD pipelines, production deployment validation, incident detection, and SEV (severity) resolution. - **Robo Dev:** Atlassian's internal brand and in-house coding agent deployed across the entire software development life cycle. Rather than acting as a simple code-completion plugin, Robo Dev assists with code reviews, continuous delivery checks, and automated incident response, utilizing underlying models from Anthropic while achieving top-tier performance on the SWE-bench benchmark.

[08:35](https://www.youtube.com/watch?v=fYh1CWadxDM&t=515s) The Power of Context and Atlassian’s Teamwork Graph

When asked how an internal tool can outperform Claude Code while running on the exact same underlying model, Rajeev Rajan boils the secret down to a single principle: context. A model’s intelligence in execution is directly constrained by the environment and data supplied to it. To give their internal coding agent, Rovo Dev, an advantage over generic coding assistants, Atlassian built an organizational data model called the "Teamwork Graph."

This graph maps the company's internal working relationships and development history. Rather than looking only at a bare repository, the agent understands who is collaborating on which pull request and which Jira issue is tied to the task. Rajeev explains:

> “Agents are as smart as the context you give and in Atlassian, we have built what is called the teamwork graph, which is, you know, who does Thomas work with on which PR, on which issue in Jira and that context really helps Rovo Dev do a much better job with the PRs that produces.”

[09:01](https://www.youtube.com/watch?v=fYh1CWadxDM&t=541s) Distributed Teams and AI as a 24/7 Sparring Partner

Gergely questions why Thomas Dohmke chose to make his early-stage startup distributed across multiple time zones, running counter to the conventional Silicon Valley wisdom that early-stage teams must sit in the same room to iterate quickly. Thomas responds that work arrangements should mirror personal relationships—everyone must find what fits their happiness, whether that means a San Francisco office, a hybrid model, or fully remote. For him, the major advantages of remote work are personal travel flexibility and continuous round-the-clock progress across time zones like Australia, Germany, Spain, Portugal, the UK, and the United States.

However, remote setups carry an inherent isolation—both the emotional loneliness of being home alone and the practical blocker of not knowing who is free to unblock a question. In an office, an engineer can look over and see if a peer is simply browsing social media or trapped in an important meeting. AI agents compensate for that deficit by serving as on-demand brainstorming and technical partners available at any hour. For example, while preparing for a weekend launch, Thomas realized his React app needed not just terms of service and a privacy policy, but also a cookie policy. Rather than tracking down an engineer or waiting until Monday, he used Cursor Composer to implement it in three seconds. Furthermore, when the US team signs off at 6:00 p.m., engineers in Melbourne are starting their day at noon, keeping Discord support and open-source contributions moving without pause.

> “And I think agents basically gave us these sparring partners, these experts that I can just ask and say, ‘Hey, I want to brainstorm on this topic. I need to write an ADR or like solve a problem.’”

Thomas notes that while companies in San Francisco regained an edge by returning to physical whiteboards, the availability of code review, coding, and research agents has leveled the playing field for remote-first teams.

```mermaid flowchart TD accTitle: AI Agents as Distributed Team Enablers accDescr: Flow showing how asynchronous distributed development relies on AI agents to eliminate blockers across time zones.

subgraph Office["Traditional In-Office Model"] A["Physical Coworker"] -->|"Visual Availability / Whiteboarding"| B["Unblocked Task"] end

subgraph Distributed["Distributed AI-Native Model"] C["Remote Engineer Alone at Odd Hours"] -->|"Instant Context & Query"| D["Coding / Brainstorming Agent"] D -->|"Immediate Resolution"| E["Unblocked Task"] E -->|"Asynchronous Handoff"| F["Next Global Time Zone (e.g., Melbourne)"] end ```

[11:51](https://www.youtube.com/watch?v=fYh1CWadxDM&t=711s) Atlassian's "Team Anywhere" Model and Instant Code Explanation

Rajeev notes that Atlassian embraced distributed operations long before the COVID-19 pandemic, meaning the shift to global remote collaboration felt natural. However, Atlassian distinguishes itself from remote-only setups by maintaining physical hubs in San Francisco, Sydney, and other cities to foster intentional in-person connection without imposing mandatory office attendance. Under their "Team Anywhere" policy, employees are free to work from wherever they choose.

For distributed software teams, Rajeev highlights how radically agents have eliminated the late-night bottleneck of debugging alone. In past decades, an engineer working at 2:00 a.m. who ran into unfamiliar code had no choice but to repeatedly read the codebase until understanding it by sheer brute force. Today, an agent can instantly explain obscure code blocks or rewrite the implementation directly, making asynchronous, independent work practical.

[12:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=777s) The Shift in Ownership: From Code Review to Verification and Artifacts

Addressing how engineering leadership and individual contributor roles are evolving, Rajeev explains that Atlassian has not radically restructured its core team ratios of engineers, product managers, and designers. Instead, the company is prioritizing what that team can produce and how much creativity can be unlocked, occasionally seeing 10x or even 100x productivity surges on specific projects.

The real evolution is occurring in accountability and ownership: - **Upstream Artifacts as Source of Truth:** Code ownership is diminishing as the creative focus moves upstream to requirements, discussions, and specs documented in Confluence, Jira, and Loom video walkthroughs. Loom recordings in particular allow engineers and designers to express intent and nuance through speech and video, which can then be ingested by AI agents to generate code and documentation. - **Verification Over Syntax:** Instead of manually pouring over syntax during code reviews, engineers are transitioning into verification specialists who define boundaries, guardrails, and expected inputs and outputs. - **Greenfield vs. Legacy Codebases:** Atlassian has experimented with zero-manual-code initiatives, intentionally barring human engineers from writing lines of code directly. This forces the team to restructure the repository and set explicit rules tailored for autonomous agents. While this approach yields massive productivity in clean, greenfield repositories, legacy codebases present far more friction. Rovo Dev and similar agents struggle when handed broad, highly tangled legacy projects, leaving manual engineering essential for older systems.

> “Instead of like a lot of code reviews and trying to understand code, which you still have to do, but the agents help you, it's about verification, right? What are the guardrails? What are the inputs and outputs that you want to verify that so that you know that the AI code is good and that the agents have done a good job.”

[15:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=943s) Backlog Inflation and the "Homer Simpson Car"

Thomas observes that the software industry has continually struggled with an overabundance of ideas. He jokes that just as a parent's ambitious Saturday morning personal plans vanish by Sunday night under family demands, software backlogs constantly swell until teams get overwhelmed, discard them, and reinvent the exact same tickets.

With AI agents, this dynamic has simply shifted one step downstream:

1. **Backlog to PR Flood:** Teams feed backlogs directly into coding agents, which rapidly convert written concepts into working code, moving the operational bottleneck from backlog management to pull request reviews. 2. **Review Fatigue to Auto-Merge:** Because human reviewers cannot keep up with the deluge of generated pull requests, organizations will soon deploy secondary agents to review, auto-merge, and auto-deploy those PRs. 3. **The Homer Simpson Car:** Without disciplined curation and architectural intent, unconstrained agentic generation will assemble a bloated, disjointed software monster—reminiscent of the disastrous car designed by Homer Simpson.

> “And what we're now doing with agents, we're shifting this one step to the right where we just feed all of that into agents, and agents write all of the code, and now you have your backlog in your pull requests. And that's the bottleneck now because you can't review all of that. And then there are going to be agents that review all that code and auto merge and auto deploy it, and what you get is the Homer Simpson car.”

[16:32](https://www.youtube.com/watch?v=fYh1CWadxDM&t=992s) Role Collapse: The Rise of Product Engineers and Design Engineers

Without disciplined design, product management, and intentional architecture, software quickly degenerates into an incoherent mess of disconnected features. Thomas Dohmke compares this danger to Homer Simpson designing a car—a bloated Frankenstein vehicle loaded with bells and whistles that completely fails its users. Maintaining high product taste requires collaboration between product managers, designers, and software engineers. However, the traditional boundaries separating those disciplines are blurring rapidly into what Dohmke describes as a massive role collapse across the software development lifecycle. Rather than handing off static specification documents, product managers are now expected to use coding agents to build working interactive prototypes themselves.

This transformation extends far beyond the core product trio. Marketers, communications professionals, and executive assistants are turning to tools like Lovable and Replit to automate their workflows and build bespoke software solutions. Dohmke raises the organizational tension explored in *The Phoenix Project*: will central IT play the role of the bad cop and block non-engineers from deploying software, or will companies adapt their governance to empower every employee to build? He traces the foundational purpose of a company back to the philosophy of the Dutch Trading Company—the idea that people working collectively in an organization can achieve vastly more than isolated individuals—and argues that the industry's central challenge is establishing secure, trustworthy guardrails so that teams can move faster without compromising stability.

```mermaid flowchart TD accTitle: Role Collapse in the Age of AI accDescr: Diagram showing traditional roles converging into builder roles powered by coding agents. subgraph Traditional["Traditional Silos"] PM["Product Manager"] DES["Designer"] ENG["Software Engineer"] OPS["Comms / Marketing"] end

subgraph Agents["AI Builders & Coding Agents"] CA["Coding Agents & Workspaces<br/>(Devin, Lovable, Replit)"] end

subgraph Evolved["Collapsed Builder Roles"] PE["Product Engineer"] DE["Design Engineer"] SE["Software Engineer"] NB["Autonomous Builders"] end

PM -->|"Builds prototypes"| CA --> PE DES -->|"Codes interfaces"| CA --> DE ENG -->|"Directs agents"| CA --> SE OPS -->|"Automates workflows"| CA --> NB ```

- Thomas Dohmke summarizes the functional realignment: “I actually think the product manager is becoming a product engineer, and the designer is becoming a design engineer, and the software engineer stays a software engineer.” - Dohmke notes the universal human tendency in software evaluation: “It's easier for us to find something bad than finding something good.” - Handing off static PRD documents is being replaced by an operational expectation that product managers ship functioning prototypes using AI tools.

---

[18:27](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1107s) Hands-On Leaders and Expanding Spans of Control

When asked how engineering management must evolve, Rajeev Rajan highlights an immediate, personal benefit: leaders can finally write code again without sinking countless hours into manual setup and scaffolding. Over the recent holidays, eager to build without encountering corporate IT guardrails, Rajan bought a personal laptop at an Apple Store, installed Claude Code, and spent his time writing Python scripts and applications. In the traditional engineering model, an engineering executive's personal standard for clean code made building full features on the side nearly impossible given their time constraints. AI agents have radically compressed that feedback loop, allowing leaders to participate in hackathons, ship features, and reconnect directly with the codebase rather than growing alienated from technical reality as they climb the corporate ladder.

```mermaid flowchart LR accTitle: Span of Control Management Structures accDescr: Contrasting high-layer binary tree structures with flat square-root organization models. subgraph Deep["Binary Tree (Deep Hierarchy)"] D1["Leader"] --> D2["Manager"] D1 --> D3["Manager"] D2 --> D4["..."] D3 --> D5["..."] end

subgraph Flat["Square Root Model (2 Layers)"] F1["Leader"] -->|"20 Direct Reports"| F2["20 Managers"] F2 -->|"20 Direct Reports Each"| F3["400 Engineers"] end ```

Alongside technical hands-on involvement, management structures are undergoing a structural flattening. Rajan argues that the conventional small span of control—where managers oversee merely three to five direct reports, or degenerate into hierarchical binary trees of two reports per manager—is giving way to much wider reporting spans. By leveraging AI to streamline managerial overhead and maintain codebase context, individual leaders can support significantly larger groups, mirroring models seen across high-output organizations.

- Rajeev Rajan observes the changing relationship between leadership and technical work: “I think one of the most exciting things for engineering leaders including myself is we can write more code now, like you know, I love writing code.” - In an organization of 400 engineers, Rajan advocates taking the square root: 20 direct reports who each manage 20 engineers, compressing the entire organization into just two layers of management. - Rajan and Dohmke cite industry precedents for expansive spans of control, including Thibaud Elziere managing 33 direct reports and Nvidia CEO Jensen Huang overseeing 40 to 50 directs.

---

[20:29](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1229s) The Fate of Career Paths: "Don't Be a Manager"

Addressing the future of traditional engineering career ladders—the predictable progression from software engineer to senior, followed by a branching fork into staff engineer or engineering manager, director, and beyond—Rajan offers blunt advice. He shares that early in his own career, a mentor told him to avoid management entirely. He successfully resisted taking on managerial duties for years, only accepting a managerial title when decisions were being made around him that he could not understand, prompting him to poke his head up and see what was happening before ultimately crossing over to "the dark side."

For hands-on engineers, Rajan believes the current era represents an extraordinary golden age. While the exact long-term horizon remains uncertain, engineers who leverage agents, write code, and stay on the cutting edge of development will thrive. In contrast, middle managers and leaders who rely on bureaucratic governance will face intense pressure as management layers contract.

- Rajeev Rajan shares his foundational career advice: “Well, first of all, you know, anytime somebody asks me about career path as an engineer, but the first thing I tell people is, 'Don't be a manager.'” - Rajan's assessment of the shift in leadership responsibilities: “I think there's less of like leadership, management, blah, blah, blah. It's more of like doing and like figuring things out in this new world.” - The emerging consensus suggests there will be fewer managerial positions overall, favoring leaders who actively build and solve problems directly over those seeking traditional managerial track promotions.

---

[21:57](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1317s) Enterprise Friction, Top-Down Agent Mandates, and the Management Shift

Dohmke reacts to Rajan’s laptop story with a tactical insight for founders pitching venture capitalists. Whenever an investor asks how a fledgling startup can compete against established incumbents who have vastly superior resources, the founder should point out that the CTO of Atlassian had to buy a consumer laptop with his own money just to write code. Rajan jokingly shoots back that he will fix Atlassian's IT restrictions once he acquires Dohmke’s startup, to which Dohmke quips that Rajan can just acquire their hardware assets for coding.

Beyond enterprise IT humor, Dohmke underscores a broader industry transformation: coding agents like GitHub Copilot, Cursor, and Devin have allowed CTOs and CIOs at the world's largest banks to become hands-on developers again. By offloading package installation and environment setup to agents, executive leaders assign tasks to agents like Devin at night, review the generated code in the morning, and immediately recognize the massive productivity shift. Unlike the historical bottom-up developer adoption popularized by Twilio's "Ask your developer" ethos, these executives are returning to their organizations and issuing top-down mandates to roll out agents, bypassing the traditional security, legal, and Citrix-bound hurdles that have historically left German and Japanese enterprises years behind on cloud adoption. Dohmke reflects that his own journey into formal management only began when Microsoft acquired his ten-person startup—noting that leading an early-stage team involves pitching and payroll rather than traditional personnel management, and that the modern manager must now navigate a world where individual technical execution is once again paramount.

- Thomas Dohmke delivers his advice for startup pitches: “For all the startup founders, every time an investor asks you, 'How are they preventing the incumbent doing the same thing that you're doing?' Just tell them that the CTO of Atlassian had to buy a laptop on his own money to start coding.” - High-level banking executives run coding experiments overnight: “I have actually I have friends in that in that space that told me stories of like on every night they would give Devin a task and and say, 'Devin, build me this.' And then in the morning we'll check it the check in with the developer at the agent and then I keep going that way and then they have their normal day-to-day as a as a CTO of of a big bank.” - Dohmke emphasizes the unprecedented velocity of tool adoption across the globe: “No other software development technology has been adopted as fast as agents, right?”

[24:19](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1459s) Management, Performance Reviews, and Developer Honesty

Reflecting on the administrative burdens of engineering management, Thomas Dohmke describes how the arrival of generative AI immediately upended corporate bureaucracy like job descriptions and performance reviews. At Microsoft, performance cycles traditionally required employees to answer roughly seven structured text fields, followed by a manager responding to each one. Dohmke recalls that lazy managers would often simply submit "I agree with you," leaving employees feeling shortchanged. Once ChatGPT became available, managers began using it to write reviews, only for employees to realize they could use it to draft their self-assessments as well. When the host jokes about whether he became CEO of GitHub with this hack-the-system mentality, Dohmke quips about an idea floated in the green room for a future event: rather than the Pragmatic Summit, holding a "Dogmatic Summit" where speakers argue purely over software engineering dogma.

Dohmke connects this back to GitHub's defining mantra: "developers first." In his experience, developers have zero tolerance for corporate messaging and public relations polish; whenever a GitHub blog post or tweet sounded overly corporate, the Hacker News community called it out instantly. He argues that this same principle applies to engineering management. Engineers instantly recognize when a manager is speaking straight versus hiding behind sugarcoated platitudes when performance is lagging. Dohmke believes AI makes deceptive management obsolete: if a manager spends an hour generating a prettified review, the engineer will simply paste it right back into ChatGPT to ask what the manager actually meant and whether AI wrote it. He likens corporate over-polishing to automated AI sales pitches—which he wishes AI would simply delete—arguing that leadership should instead be built on authentic, direct communication:

> “And I think the same is true for being a people manager, an engineering manager of a team: like, your team knows exactly whether you're talking straight to them and giving them the truth, or whether you're sugarcoating that they actually are doing so well and you're kind of like trying to give them the message that you either improve or you get out, right?” — Thomas Dohmke

[27:14](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1634s) Agentic Coding at Atlassian and Future Predictions

When asked about the most substantial shifts already taking place inside engineering organizations, Rajeev Rajan emphasizes that agentic coding has fundamentally transformed Atlassian. Their internal developer agent, Robo Dev, is now deployed across all of Atlassian's engineers. Rather than relying on purely manual implementation and human-driven code inspection, agents are handling substantial portions of the software development lifecycle, including diff analysis, pull request triage, and security scanning. The workflow gains have extended beyond engineering into product management and design; PMs are leveraging tools like Replit to construct functional, interactive prototypes rather than static text specifications, giving engineers clearer reference implementations.

Looking ahead, Rajan envisions a transition toward building products with zero lines of manually written code. In this future state, developers and teams will rely on automated agent code reviews rather than laborious human diff inspections. Engineering effort will pivot toward testing boundary conditions, security posture, and runtime reliability. Projecting two or more years into the future, Rajan speculates that developers might no longer write in traditional programming languages or work inside IDEs at all. High-level programming languages originally emerged to spare humans from writing assembly; if AI agents can manage execution and debugging directly, the entire abstraction layer may shift toward high-level intent executed by an underlying "AI JVM":

> “I think we move towards more verification of inputs and outputs to see the system performing according to the right security, reliability, performance bars, less about inspection of code.” — Rajeev Rajan

```mermaid flowchart TD accTitle: Evolution of Software Development Workflows accDescr: Diagram contrasting traditional manual coding and review with the emerging agentic and intent-driven verification models.

subgraph Traditional["Traditional SDLC"] direction TB T1["PRD & Static Specs"] --> T2["Manual Coding in IDE"] T2 --> T3["Peer Code Inspection"] end

subgraph Agentic["Current Agentic SDLC (Atlassian)"] direction TB A1["Interactive Specs (Replit)"] --> A2["Robo Dev & Agent Generation"] A2 --> A3["Agent-Assisted Reviews & Scans"] end

subgraph Future["Future Intent Model (2+ Years)"] direction TB F1["High-Level Intent Definition"] --> F2["AI Runtime Engine / AI JVM"] F2 --> F3["Input/Output & Constraint Verification"] end

Traditional -.-> Agentic Agentic -.-> Future ```

- **100% Engineer Adoption**: Robo Dev is used across the entire Atlassian engineering staff. - **+89% Pull Request Velocity**: Pull requests completed per engineer have surged by 89%. - **-42% Cycle Time**: Issue cycle time has dropped by 42%. - **51% Vulnerabilities Caught**: Agents now catch 51% of all security vulnerabilities before production. - **Improved DORA Metrics**: Across-the-board acceleration in deployment frequency, lead time, and stability benchmarks.

[29:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1783s) The CEO Dilemma: Exploding Token Costs vs. The Return of Joy in Coding

From the chief executive seat, Thomas Dohmke outlines two dramatic changes emerging alongside agentic tooling: an operational expense shock and a renaissance in developer enjoyment. Historically, engineering leaders managed relatively static, predictable OpEx budgets dominated by payroll, employee benefits, and travel and entertainment. With autonomous agents, engineering teams face variable, consumption-based token expenses. When developer productivity rises, token consumption spikes proportionally, creating an inversion where corporate finance asks managers to rein in their most productive engineers to stay within budget. While early-stage startup founders only face this existential burn when runway dwindles, leaders at large corporations must now restructure how they forecast infrastructure spend without resorting to layoffs to offset compute fees.

At the same time, Dohmke celebrates how AI agents have brought back the pure fun of programming. Remembering his own beginnings hacking on a Commodore 64 and a Pentium PC in the early 1990s, he recalls spending frustrating nights blocked on compiler errors with only printed manuals and a weekly Wednesday computer club for help. Today, rather than losing hours to cryptic terminal build errors, broken NPM packages, or tedious unit tests, engineers can offload chores directly to agents. Recounting an NDA session at OpenAI evaluating their native Mac app for Codex, Dohmke shares that he generated three complete native macOS SwiftUI apps—including a persistent menu bar utility—in a single afternoon without writing or inspecting the underlying code:

> “All of a sudden we have flexible token costs, and the more productive your developers are, the more your costs are going through the roof—and you actually create an inversion where you have to slow down some developers because they're burning so many tokens.” — Thomas Dohmke

- **Budgetary Shift**: Transitioning from fixed headcount OpEx (salaries, benefits, T&E) to variable, usage-driven GPU and token consumption. - **The Financial Dilemma**: A corporate tension between encouraging high agentic output and capping monthly token burn across engineering units. - **Automating Undesirable Tasks**: Offloading build failures, package dependency resolution, and unit test generation (drawing an audience laugh about whether anyone besides Kent Beck genuinely loves writing tests). - **No-Code Prototyping**: Generating native macOS SwiftUI menu bar applications within minutes, bypassing historically cumbersome Xcode configuration steps like hiding dock icons.

[32:50](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1970s) Reclaiming the Joy of Building Software

Reflecting on the deeper personal impact of AI on development workflows, the discussion turns to how reducing friction fundamentally rescues the creative impulse in programming. In traditional development, the friction of setting up environments, configurations, and toolchains meant that the original inspiration behind an idea had often flown away by the time an engineer actually got their first build running. AI changes that dynamic entirely by collapsing the distance between an initial spark and working code. This transformation matters just as much for hobby projects—the very tinkering that originally drew people into software engineering in the first place—as it does for large-scale enterprise environments at companies like Atlassian, Entire, or GitHub.

While business metrics often dominate the corporate narrative around generative tooling, the real payoff for engineers is experiential rather than financial. As Thomas Dohmke emphasizes: “The productivity is great, you know, for the CFO and the CEO and the public stock market, but what really matters to us is our job is fun again.” The moderator echoes this sentiment completely before concluding the panel and inviting the audience to give Rajeev Rajan and the speakers a round of applause to close out the session.

## Notable quotes > [16:32](https://www.youtube.com/watch?v=fYh1CWadxDM&t=992s) I actually think the product manager is becoming a product engineer, and the designer is becoming a design engineer, and the software engineer stays a software engineer. — Thomas Dohmke

> [00:05](https://www.youtube.com/watch?v=fYh1CWadxDM&t=5s) I find that the discussion about using AI to produce more efficiency and maybe smaller teams and fewer engineers is missing the point. It's more about what can you create now with AI that you could not create before. — Rajeev Rajan

> [32:50](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1970s) The productivity is great, you know, for the CFO and the CEO and the public stock market, but what really matters to us is our job is fun again. — Thomas Dohmke

> [27:14](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1634s) I think we move towards more verification of inputs and outputs to see the system performing according to the right security, reliability, performance bars, less about inspection of code. — Rajeev Rajan

> [29:43](https://www.youtube.com/watch?v=fYh1CWadxDM&t=1783s) All of a sudden we have flexible token costs, and the more productive your developers are, the more your costs are going through the roof—and you actually create an inversion where you have to slow down some developers because they're burning so many tokens. — Thomas Dohmke

## Mentioned Adobe Firefly, Anthropic, Apple, Atlassian, Block, Claude Code, Codex, Commodore 64, Confluence, Cursor, Cursor Bugfinder, Cursor Composer, Devin, Entire, Gergely Orosz, GitHub, GitHub Copilot, Google, Hacker News, Jensen Huang, Jira, Kent Beck, Loom, Lovable, Microsoft, Minecraft, Nvidia, OpenAI, Rajeev Rajan, Replit, Rovo Dev, SWE-bench, The Phoenix Project, The Pragmatic Engineer, The Pragmatic Summit, Thibaud Elziere, Thomas Dohmke, ThoughtWorks, Twilio

## Video description With Thomas Dohmke (cofounder & CEO, Entire, previously CEO at GitHub) and Rajeev Rajan (CTO, Atlassian).

More details in this accompanying article: https://newsletter.pragmaticengineer.com/p/the-future-of-software-engineering-with-ai

Recorded at The Pragmatic Summit: https://www.pragmaticsummit.com

0:00 Intro 0:46 What an AI-native team looks like 5:08 How teams are actually using agents day-to-day 8:05 AI-native SDLC and internal coding agents 9:03 Distributed teams 12:57 How engineering, PM, and design roles are changing 18:32 What engineering leaders should do differently 22:32 Organizational resistance 24:01 Management in the agent era 28:33 Future predictions

[Source](https://www.youtube.com/watch?v=fYh1CWadxDM)

Reading summary

At the Pragmatic Summit, tech leaders Rajeev Rajan and Thomas Dohmke argue that becoming an AI-native engineering organization is not about shrinking headcounts, but shifting engineering focus from manual syntax toward intent, verification, and agent orchestration. The AI-Native Shift Across the SDLC (0:05) According to Atlassian CTO Rajeev Rajan, AI nativity represents an operational pivot toward orchestrating agents rather than writing manual code. In some internal Atlassian teams, engineers write zero lines of code, driving 2x to 5x productivity gains while traditional role boundaries dissolve as product managers and designers generate working prototypes directly. Rajan notes that because implementation is increasingly commoditized, critical friction points have migrated to the 'left of code' (intent specification in tools like Confluence) and the 'right of code' (CI/CD, automated deployment validation, and incident resolution). Context Engines and Distributed Team Sparring (8:35) A key factor separating high-performing internal agents from generic models is organizational context. Rajan notes that Atlassian's internal tool, Rovo Dev, outperforms models like Claude Code despite running on identical Anthropic backbones because it leverages a proprietary 'Teamwork Graph' that connects Jira issues, pull requests, and cross-team collaborations. For distributed organizations, Entire co-founder Thomas Dohmke explains that coding agents serve as 24/7 sparring partners, providing immediate answers, architectural reviews, and unblocking late-night progress across distant time zones without requiring live coworkers. Verification, Backlogs, and the Risk of Bloat (12:57) As human engineers transition from writing syntax to acting as verification specialists, the traditional software development lifecycle faces a bottleneck inversion. Dohmke warns that directly routing bloated ticket backlogs into autonomous coding agents will trigger a flood of unreviewed pull requests, eventually leading teams to deploy automated review-and-merge agents. Without disciplined architecture and product taste, this cycle threatens to produce disjointed, over-engineered software comparable to the 'Homer Simpson car.' Consequently, engineering ownership is increasingly anchored to upstream requirements, guardrails, and input-output verification rather than manual diff inspections. Management Flattens as Leaders Reconnect With Code (18:27) Agentic coding is transforming engineering leadership by lowering toolchain friction, enabling executives and managers to build functional code directly. Rajan advocates flattening corporate structures using a square-root organizational model—such as two layers of 20 managers overseeing 400 engineers—arguing that expanding spans of control and AI-driven workflows will decrease the demand for traditional middle management. Concurrently, Dohmke observes top-down mandates emerging even within conservative sectors like banking, where executive leaders experiment directly with agents overnight and bypass bureaucratic friction to push tool adoption across their enterprises. Enterprise Economics and Developer Satisfaction (27:14) The widespread rollout of autonomous tools introduces new financial and cultural dynamics. At Atlassian, Rovo Dev has achieved 100% engineer adoption, yielding an 89% boost in pull request velocity, a 42% decrease in cycle time, and automated detection of 51% of pre-production security vulnerabilities. However, Dohmke highlights a growing corporate dilemma: engineering budgets are shifting from predictable, fixed headcount OpEx toward volatile, usage-based token consumption. Despite this cost tension, both leaders note that eliminating tedious setup, build failures, and boilerplate tasks has revived genuine enjoyment and experimentation in software creation. While AI tooling delivers measurable velocity gains and simplifies coding, engineering organizations still face unresolved challenges around managing variable token consumption, maintaining rigorous system architecture against automated feature bloat, and navigating enterprise IT guardrails.

Source quotes

[16:32] Thomas Dohmke: I actually think the product manager is becoming a product engineer, and the designer is becoming a design engineer, and the software engineer stays a software engineer. [0:05] Rajeev Rajan: I find that the discussion about using AI to produce more efficiency and maybe smaller teams and fewer engineers is missing the point. It's more about what can you create now with AI that you could not create before. [32:50] Thomas Dohmke: The productivity is great, you know, for the CFO and the CEO and the public stock market, but what really matters to us is our job is fun again. [27:14] Rajeev Rajan: I think we move towards more verification of inputs and outputs to see the system performing according to the right security, reliability, performance bars, less about inspection of code. [29:43] Thomas Dohmke: All of a sudden we have flexible token costs, and the more productive your developers are, the more your costs are going through the roof—and you actually create an inversion where you have to slow down some developers because they're burning so many tokens.

Original transcript

[0:05] You know, when we [music] organized this [0:06] this event, we we just wanted it to be [0:09] the answer Look look at the most [0:11] important questions that we're facing at [0:13] that time. And this was 5 months ago. [0:14] And we thought some of it might be AI, [0:16] but it turned out to be AI is is [0:18] everywhere. So, I'm I'm not going to [0:20] beat around the bush. [0:22] The two of you are very similar in many [0:24] ways. You have [0:27] Not like that. [0:28] >> [laughter] [0:31] [gasps] [0:31] >> You've You You You've run or are running [0:34] large organizations. You're building [0:37] brands that developers love and and use [0:39] and and are engaged with. And Thomas, [0:41] you're now starting something completely [0:43] new, so you're also doing something [0:44] completely different. What is an [0:47] AI-first or AI-native team mean to you? [0:52] And I'll start with you, Rajeev. Sure. [0:54] For First of all, Gergely, thank you for [0:55] inviting me and thanks everyone for [0:57] coming. It's The energy here is just [0:59] palpable. So, like it's really great to [1:00] be here. And I'm I'm really excited to [1:03] be talking about, you know, AI-native [1:05] stuff. Everyone wants to talk about AI [1:06] these days, so it's fun. Um but what [1:09] does an AI-native team look like? Um [1:11] Well, first of all, you know, it starts [1:13] with the mindset, right? You have to [1:14] sort of really believe in uh doing [1:17] AI-native work and working with agents [1:19] and things like that. We have teams at [1:21] Atlassian engineering team, some of [1:22] which are still doing the more [1:23] traditional way of of coding and [1:25] building software cuz we do have legacy [1:27] systems that take that. But we have a [1:29] number of AI-native teams where [1:31] engineers are basically writing zero [1:33] lines of code. It's all agents. It's [1:35] orchestration of agents. Um what we are [1:37] finding is the lines are blurring [1:39] between PM, design, and engineering [1:41] where uh PMs are writing code, designers [1:43] are writing code. This is basically [1:45] leading to more productivity, generally [1:47] speaking. And um the thing I find is [1:49] that the teams are not necessarily [1:51] getting smaller, but they are producing [1:53] a lot more, sometimes 2x, 5x more. And [1:56] uh the creativity is going up. What you [1:58] build is is much more creative. You can [2:01] put in like screenshots of things and [2:03] design, you know, more modern UX. [2:06] Um and and then you can also, between [2:08] PMs, designers, and engineers, the the [2:10] distance is shrinking as well. So, [2:12] that's making for more uh vigorous [2:14] conversation and more creativity. I find [2:17] that the discussion about using AI to [2:19] produce more efficiency and maybe [2:20] smaller teams and fewer engineers is [2:22] missing the point. It's more about what [2:24] can you create now with AI that you [2:25] could not create before. And how can you [2:27] be that much more productive? And how [2:29] can you have that much more joy? [2:33] You know, I I think there's multiple [2:34] answers to this. Rajiv gave one of them. [2:36] If I think about the word AI native in [2:38] the same context as cloud native, um [2:40] when GitHub started in 2008, nobody [2:42] spoke about cloud native. It is a term [2:44] that was introduced after the fact, [2:46] after in identifying how all these [2:48] companies reinvented how they're [2:49] deploying and and and developing [2:51] systems. And I think the same is going [2:52] to be true for AI native. What we're [2:54] calling AI native now is going to be [2:56] very different than what is going to be [2:57] AI native in a few years. And I have two [3:00] two boys, 13 and 11. And most of the [3:02] time they're playing Minecraft. [3:03] Sometimes I can also convince them to [3:04] code. But certainly they are AI native. [3:06] You know, one day they came home, I [3:08] think it was a year or two ago, and they [3:10] showed me their cell phones and they had [3:11] like puppy images on the on the front [3:13] page on the home screen. And they used [3:15] Adobe Firefly to generate these images. [3:17] And I'm like, "How the hell did you find [3:19] Adobe Firefly?" "Oh, everybody in school [3:21] is using it." And I think that's the AI [3:22] native generation. Those that are [3:24] growing up up now with these agents, for [3:26] them it will be just so natural to use [3:28] an agent instead of going to, you know, [3:30] a Google search or um um you know, [3:32] trying to find it to do it the the the [3:34] traditional way. And I think if you're [3:35] all honest to ourselves, you know, [3:37] there's a lot of, sorry, bull out there [3:39] of how all day-to-day is AI AI native [3:42] and I'm using agents for everything. You [3:43] know, I'm a startup founder. Most of the [3:45] time I'm still dealing with HR systems [3:47] and my my month-end close and getting, [3:50] you know, director's of board insurance. [3:52] And that's a form that I have to fill [3:53] out, and no agent helps me with any of [3:55] that. And if you hear that in podcast, [3:57] I'm like, "Sure, sure, sure." You know, [3:58] like, in theory, that is my life, but in [3:59] reality, uh you know, yesterday we [4:01] announced uh my my company. Since then, [4:04] I got like hundreds of emails from [4:05] investors that want to absolutely still [4:07] angel invest into the seed round. People [4:09] that have 12 years of experience are the [4:10] best developers, you know, on the [4:12] planet, yet they're sending me an email [4:13] to to apply for a job. And and I'm I'm [4:16] looking for the agent that solves all [4:17] that for me instead of just trying to [4:19] figure out how can I be both nice human [4:21] to give them a response, but also let [4:22] them know that I'm not interested in, [4:24] you know, [4:25] that conversation right now because I [4:26] want to build a company. So, I think [4:28] that's the like the the core crux of AI [4:31] native teams today in a software [4:32] development. Yes, we're going to use [4:34] cloud code or or some agent to build [4:36] code, but no, we're not going to feed [4:38] markdown files into that like 3,000 [4:40] software engineers all collaborating on [4:42] markdown. That is a nightmare, right? Um [4:44] if you have then folks in Germany, you [4:46] know, that speak English with an accent [4:48] or in Spain or in India and China and [4:51] whatnot, that don't actually are as [4:52] fluent in English, it's actually an even [4:54] worse nightmare because programming [4:55] language is great. It reduces vocabulary [4:58] on like 20 words that everybody can [4:59] speak. As soon as you have to describe a [5:01] feature in a language that you don't [5:03] actually think in, it's really, really [5:04] hard, and I think we haven't figured any [5:05] of that out. [5:07] And how are your teams today using [5:10] tools? How have their workflows changed? [5:14] I mean, I think the biggest change in [5:15] the workflow is that um you basically [5:17] most uh developers that start green [5:20] field from scratch today and and have [5:21] used cloud code is that they force [5:23] themselves to not look at the code. [5:25] Uh and that they basically it starts [5:26] with that that's happening at your [5:27] teams, right? That's happening. I think [5:29] that's happening everywhere in the [5:30] industry. Like, in all the people I'm [5:31] interviewing, uh whether they work at [5:33] Microsoft GitHub or Atlassian or [5:35] ThoughtWorks or or Block or so. Easy [5:37] with the poaching there. [5:38] Well, I'm [5:41] They're all coming to me, you know. [5:42] >> [laughter] [5:44] >> But all the all these [5:46] Yeah. Yeah, yeah. [5:47] >> [clears throat and laughter] [5:49] >> Well, you know, it um you I thought [5:52] about a third of the our team of my [5:54] startup entire is Australian because one [5:56] of the co-founders [5:58] is actually um went to high school with [5:59] me in in East Berlin and then immigrated [6:01] to Australia. Um and so the Australian [6:03] press didn't [6:04] um [6:05] let that opportunity go to a little [6:07] bit on Atlassian yesterday when the [6:09] announcement came because your stock [6:11] price is down and whatnot has nothing to [6:12] do with us, but of course you know, [6:13] that's not how the press works. [6:15] It's all the sad stuff, you know. [6:16] >> Yeah. Anyway, um where was I? [6:18] Um [6:21] Developers, you know, that want to be AI [6:22] native, what they're doing is try to [6:25] look at little as code as poss- at the [6:26] code as possible and force yourselves to [6:29] figure it out with a prompt and a [6:30] reasoning process and invoicing intent, [6:32] right? And in same way with code review, [6:34] ideally, you know, I never had read the [6:36] code line by line because that's going [6:37] to become increasing bottleneck. I have [6:39] like Cursor backboard or one of these [6:41] tools point out the mistakes to me and [6:43] I'm waiting for the moment and I think a [6:45] a a [6:46] previous session alluded to this that [6:47] let's just have the code review bot or [6:49] agent work with the coding agent, why do [6:51] we need the human in the middle of that? [6:53] And I think that's where that the what [6:55] the most AI native developers are right [6:57] now is the ones that [6:58] have figured out how to do that. And [7:00] that is a skill in itself and that's I [7:02] think answering the question, are we [7:03] going to replace humans with agents? No, [7:05] we're up-leveling the humans to become [7:07] the the masters of these of these [7:09] agents. [7:11] Yeah, on tools, I think like the there's [7:13] two parts to it, right? One is that [7:14] coding and implementation is becoming [7:16] free to the point where the bottleneck [7:18] is shifting to what I call the left of [7:20] code and the right of code. On the left [7:22] of code, it's about planning and [7:24] specking, and they're increasingly one [7:26] of the tools we are using in Atlassian a [7:28] lot is Confluence because Confluence is [7:30] where the intent and the spec and yes, [7:32] it's mostly English language and Thomas [7:34] makes a good point about language, but [7:36] that's where you're putting in really [7:38] what you want to build, Uh, for [7:40] product-oriented engineers. They're [7:42] going in and putting in a lot of [7:43] comments and our agents are able to read [7:46] the comments and go off in a route loop [7:48] and you know, solve things, which is [7:49] really amazing. Uh, but yeah, left of [7:51] code and then right of code, it's the [7:52] standard stuff, CICD, deployment, [7:55] incidents, SEVs. How do you find that [7:57] out? So, using agents to do that is is [7:59] what we're doing. So, I'd say we are [8:01] looking at it holistically across the [8:03] entire software development life cycle. [8:05] We call it the AI-native SDLC, all the [8:07] way from ideation to coding to like [8:09] deployment and production. We are we are [8:11] changing the tool set quite a bit. Okay. [8:13] What about Robo Dev? Tell me what Robo [8:15] Dev is. [8:16] >> Yeah, yeah, yeah. So, Robo Dev is a [8:18] coding agent, but it's also our brand [8:20] for like doing things across the entire [8:22] SDLC. So, we're using it for code [8:24] reviews, we're using it for CICD, we're [8:26] using it for incident resolution. [8:28] >> So, you built your own coding agent. [8:30] >> Yes. [8:30] Now, here's an interesting thing is we [8:32] are using Anthropic's model, [8:33] but in the SWE benchmark, we actually [8:35] beat Claude code, [8:37] which is sounds amazing. How do How do [8:38] you do that using their model? Well, it [8:40] comes down to one magic word, which is [8:42] context. [8:43] Agents are as smart as the context you [8:45] give and in Atlassian, we have built [8:47] what is called the teamwork graph, which [8:49] is, you know, who does Thomas work with [8:51] on which PR, on which issue in Jira and [8:55] that context really helps Robo Dev do a [8:57] much better job with the PRs that [8:58] produces. [9:01] What is happening with distributed [9:02] teams, Thomas? You mentioned that your [9:05] team is spread across a bunch of [9:07] different time zones, which is super [9:08] unusual for [9:10] early stage startup. Usually, the [9:11] conventional wisdom is like be in the [9:13] same office, you're going to be riffing [9:14] at the each other. [9:16] Why did you decide to go distributed and [9:18] does AI have to do anything with this? [9:21] First of all, I want to say, you know, I [9:22] I'm a strong believer of everybody needs [9:24] to find their own happiness, right? And [9:26] that's just similar to the relationship [9:28] that you have in your personal life, [9:29] it's the same with the relationship that [9:30] you have with your company. There is not [9:32] one perfect approach and if you want to [9:34] work in a company that has a beautiful [9:35] office in San Francisco, great. You [9:37] going to work in a hybrid scenario, also [9:39] great. And I love working in remote [9:40] teams because I love traveling. [9:42] I love the 24/7 coverage if you have [9:44] people in Australia, in Germany, in [9:45] Spain, [9:46] in Lisbon, and UK, whatever in in in the [9:49] United States in the different time [9:50] zones. And that makes my life happy and [9:52] doesn't mean that anybody else is wrong [9:53] in in how they're running their company. [9:55] Um what it does though is if you have a [9:57] remote team is that you're lonely, [10:00] right? And lonely in might be in the [10:02] kind of like COVID alone at home sense, [10:04] but also in the who is available for me [10:07] to ask the question. And it's much [10:09] easier to do that in an office [10:10] environment because you can kind of [10:11] figure out what Gergely is only, you [10:13] know, surfing on X and and and posting [10:15] and whatnot. And so I can ask him a [10:17] question. And never never. [10:20] >> [laughter] [10:21] >> And and [10:23] and in the same time if you're busy in a [10:24] conversation with Rajiv then obviously I [10:26] won't run into the conference room and [10:27] ask you, "Hey, can you do this code [10:29] review for me?" And I think agents [10:31] basically gave us these sparring [10:33] partners, these experts that I can just [10:35] ask and say, "Hey, I want to brainstorm [10:37] on this topic. I need to write an ADR or [10:40] like solve a problem." You know, I was [10:42] over the weekend preparing a launch, so [10:44] figured out I need not only terms of [10:46] service and a privacy policy, I also [10:47] need a cookie policy. So I was trying to [10:49] figure out how do I do that in the React [10:51] app and I just asked Cursor Composer to [10:53] do that for me and it was done in 3 [10:54] seconds, right? And I think that's the [10:56] the remote work and with the help of [10:58] agent has gotten a new level that wasn't [11:00] possible before because I've always [11:02] somebody available. My code review [11:03] agent, my coding agent, you know, my [11:05] brainstorming agent, my research agents, [11:07] all these kind of things. And then I and [11:09] I think that's for us the huge benefit, [11:10] especially if you have these launch [11:11] days, right? If you're everybody in the [11:13] same time zone in the same office, at [11:15] some point you need to go home. Like [11:16] that's just the reality. If you have [11:18] folks in Australia, by the time it's [11:19] 6:00 p.m. here, it's like noon or [11:21] something in Melbourne. And so they're [11:23] still working and maintaining, you know, [11:24] the engagement on Discord and any open [11:27] source project. So I think in some ways, [11:29] you know, agents have gotten us an [11:31] advantage again, you know, for being [11:32] remote first. [11:34] Uh and that, you know, other teams that [11:36] work in the office together, you know, [11:37] have on on their side when when they can [11:39] brainstorm in front of white boards. So, [11:41] it evened out a little bit of the [11:42] competitive disadvantage that certainly [11:44] has evolved here in San Francisco as [11:46] most of the AI native companies have got [11:49] gotten back into office. And Rajiv, how [11:51] are you seeing this cuz you've been you [11:53] you have distributed teams. Is it [11:54] changing? Yeah. Um well, we have we are [11:57] actually Atlassian has been uh leaning [11:59] into distributed teams way before, like [12:01] even before COVID. So, when actually [12:02] COVID happened, it was super natural for [12:04] us to um to to be in that kind of [12:06] situation. Our software naturally is for [12:09] collaboration across distributed teams [12:11] that we're not remote. We have offices. [12:13] We have offices in San Francisco, in [12:14] Sydney, in in different parts of the [12:15] world. So, we do believe in like that [12:17] intentional togetherness you get when [12:19] human beings come together and and work [12:20] together. So, we're not like a [12:22] remote-only, remote-first kind of [12:23] company, but uh we don't mandate you [12:25] coming into the office. We are like you [12:27] can work from anywhere. We call it team [12:28] anywhere. You can work from anywhere. [12:29] You can work with people. And to [12:30] Thomas's point, I think agents have [12:32] changed things a lot. Like I remember [12:34] the days when I was in the office at [12:36] 2:00 a.m. writing code and you get [12:37] stuck. And all you can do is like read [12:40] the code and read the code more until [12:41] you understand it and figure it out. Uh [12:43] well, now you can ask an agent and the [12:44] agent can explain it for you or even [12:46] better do the code for you. So, I think [12:48] with agents it's gotten even better and [12:49] easier for us to be able to be [12:50] distributed in this in this fashion. [12:53] And you know, like a big thing that [12:55] we're all seeing, you're seeing it as [12:56] well, [12:57] the role of software engineer changing [12:59] and the role of the engineering leader, [13:01] the engineering manager changing. From [13:02] your vantage point, what are you seeing [13:05] happening so far? What do you expect and [13:08] especially looking at Atlassian, are are [13:10] you are you doing any change in in terms [13:12] of like defining the role or thinking [13:14] about or relaxing some of the things [13:16] that you've kind of had had in place [13:18] before? [13:19] Yeah, we we think about it in terms of [13:21] like uh what changes with respect to [13:23] ownership, [13:25] things like that, right? And what we're [13:27] are finding is it's less about code [13:29] ownership, it's more about like now the [13:30] artifacts are shifting to things like [13:32] Confluence and Jira and even Loom. We [13:34] have a lot of interaction through a [13:36] product we acquired called Loom that's [13:37] now part of the Atlassian product. And [13:39] you can express a lot more intent and [13:41] thoughts in video. And so feeding that [13:43] into our AI agents and using that to [13:46] produce better artifacts, [13:48] the ownership is shifting towards that. [13:50] And then the accountability part is [13:51] increasing as well. Instead of like a [13:53] lot of code reviews and trying to [13:54] understand good, which you still have to [13:56] do, but the agents help you, it's about [13:58] verification, right? What are the [14:00] guardrails? What are the inputs and [14:02] outputs that you want to verify that so [14:04] that you know that the AI code is good [14:06] and that the agents have done a good [14:07] job. That's where the ownership and [14:10] accountability is shifting and so that's [14:11] that's how we are thinking about it. But [14:13] in terms of team structures and managers [14:15] and PMs and designers and engineers, we [14:16] aren't [14:17] thinking we're not doing like radical [14:19] changes yet. What we are focusing on is [14:22] that team structure, that team that's [14:23] producing the feature, how can they do [14:25] more? How can they be more creative? [14:27] We're not going down the path of saying, [14:28] "Oh, let's do it, you know, with fewer [14:30] people necessarily." That's not the [14:31] biggest angle. In some cases we do find [14:34] 10x even 100x more productivity and we [14:36] then reshape the team for that. But our [14:38] angle is more how do you unleash more [14:40] creativity and how do you do more? Can [14:42] you tell me a tiny bit more when you say [14:43] like you see more productivity I mean [14:44] you reshape the team for that. What [14:47] could that mean or what does that mean? [14:49] Well, we've tried some projects where we [14:51] are like, "Hey, what if we didn't write [14:53] any code manually? Like what does that [14:55] look like, right?" And that forces you [14:57] to think differently, that forces you to [14:59] organize the repo differently, that [15:00] forces you to [15:02] set up the rules for the agents [15:03] differently. The agents [15:05] don't have enough context. When you have [15:07] a repo with full of code, it can start [15:09] off in a better place. And so that [15:10] forces you to sort of really be AI [15:12] native AI first. And we're finding that [15:14] in those cases we make a lot of [15:16] progress, you can get real good [15:17] productivity, but [15:19] if you have a legacy code base that has [15:21] been around for a long time, it's not as [15:23] easy, right? We find that, you know, it [15:25] takes a lot more effort and things like [15:27] that. And so, we've done a lot of [15:29] progress with Rover Dev, but it's not [15:30] yet at the point where you can give it [15:31] like a complex project on a legacy code [15:34] base, and I think that's a hard problem [15:35] that a lot of people are working on. I [15:36] think we'll get there very soon, but [15:38] that's an area where you can't go and [15:40] and be as aggressive. [15:43] I have I have two angles on this. I [15:44] think one is, you know, we we're [15:45] constantly in this problem that we have [15:48] way too many ideas in life and way too [15:49] many things to do, you know, one of my [15:51] jokes is that when you're single, your [15:53] Saturday morning is great, you have all [15:54] the plans for the weekend. When you're [15:55] married with kids, [15:57] all the plans that you had on Saturday [15:58] morning didn't happen by Sunday night [16:00] because your family determined what [16:01] you're actually doing over the weekend. [16:03] And the same is true in software [16:04] projects. And the way we're solving this [16:05] is we're writing things down into do [16:07] lists and then we're moving them into [16:08] linear backlogs, and your backlog gets [16:10] longer and longer, and somebody just [16:12] throw it all the way and start fresh and [16:13] bring up the same ideas again. And what [16:15] we're now doing with agents, we're [16:16] shifting this one step to the right [16:18] where we just feed all of that into [16:19] agents, and agents write all of the [16:21] code, and now you have your backlog in [16:22] your pull requests. And that's the [16:23] bottleneck now because you can't review [16:24] all of that. And then there are going to [16:26] be agents that review all that code and [16:28] auto merge and auto deploy it, and what [16:30] you get is the Homer Simpson car. [16:32] Right? Because all the ideas you had, [16:33] you know, without without any process [16:35] and any creativity and and and product [16:36] management and whatnot leads to products [16:38] that have lots of features that look [16:40] like Homer Simpson. I don't know if [16:41] everybody has that picture in your head. [16:44] The The flip side of that is, you know, [16:45] that and then obviously we need to so [16:47] that we still need product managers and [16:48] designers and engineers to actually [16:50] architect products that are really [16:52] great. And every time you're using a [16:54] product that's not great, you know [16:55] exactly that that's the case, right? [16:57] Like that's It's easier for us to find [16:58] something bad than finding something [17:00] good. [17:01] At the same time, I think they're seeing [17:02] going to see a massive role collapse [17:04] between the traditional engineering [17:06] roles, right? [17:07] You're not the pragmatic product product [17:08] manager and the product manager [17:10] designer, but I actually think the [17:11] product manager is becoming a product [17:13] engineer, and the designer is becoming a [17:14] design engineer, and the software [17:16] engineer stays a software engineer. and [17:17] so the Venn diagram of these roles is [17:19] overlapping much more and I think it was [17:21] this morning session or maybe it was the [17:22] off-the-record session yesterday, but uh [17:24] we're seeing a lot of that where product [17:26] managers in companies um are now forced [17:29] to as an ex- as an expectation of their [17:31] job to use a coding agent to build a [17:33] prototype instead of just writing a [17:34] document and then handing it off. [17:36] Now, that's the obvious part of this, [17:38] but it's also true for your marketer, [17:41] for your comms people, for your [17:42] assistant. All those folks are already [17:45] using Lovable or Repl.it or any of these [17:47] tools to actually automate part of their [17:49] life. And then the question becomes is [17:50] IT the bad cop uh like in the I think it [17:53] was in the Phoenix Project that blocks [17:54] everybody from deploying, or do we find [17:56] ways in the organizations to actually [17:58] let everybody be a builder and and [18:00] contribute to back to what ultimately is [18:02] the goal of every organization, which is [18:04] as a team together we're much more [18:05] powerful than as individuals, right? [18:07] That's the Dutch Trading Company [18:08] philosophy if you if you go back where [18:10] companies come from. And we have to find [18:12] these processes and I think that's the [18:14] thing that we haven't really figured out [18:15] of how in a secure way and uh [18:18] trustworthy way we can ship amazing [18:20] products, you know, by moving much [18:21] faster through the life cycle while at [18:23] the same time empowering everybody in [18:24] the company to to do so. [18:27] And we we've talked about this is the [18:28] engineer role and of course like how [18:30] designers and and product managers are [18:31] getting closer. What about the [18:32] engineering leader? You know, you've got [18:34] a lot of outstanding engineering leaders [18:37] inside Atlassian. How do you see their [18:39] roles changing and you Thomas like as [18:40] you're going to be hiring, who would you [18:42] hire for like before you would have [18:44] obviously hired for every 10 engineers [18:45] like an engineering manager or something [18:47] like that. How how will that change for [18:48] you? So I'll I'll start with you Rajiv. [18:51] Yeah, I think one of the most exciting [18:52] things for engineering leaders including [18:53] myself is we can write more code now, [18:55] like you know, [18:57] um I love writing code. I I over the [18:58] holidays, you know, bought a laptop and [19:01] you know, because sometimes you can't [19:02] install things because of IT, but like I [19:03] bought I bought [laughter] a [19:05] I bought my own personal laptop at the [19:07] Apple Store and installed Cloud Code and [19:09] you know, built an app uh bunch of [19:10] Python scripts and things like that. Um, [19:13] and and you know, [19:14] for someone who has grown up writing [19:16] code, for my bar for my own code is [19:17] super high, like as it is for all my [19:19] engineers. And so, like for me to take a [19:21] time out to go and build a whole new [19:22] feature, it it's it's a lot of time in [19:24] the old traditional way. But now I can [19:26] do it much faster with Robo Dev, with [19:29] with agents and things like that. And [19:31] it's always satisfying to go join a [19:32] hackathon, build something, and write [19:34] code. And so, for all the leaders, I [19:36] think it's like you know, you can get a [19:37] lot more connected because sometimes as [19:39] a leader you go up the chain and then [19:41] you get more disconnected from code and [19:43] engineers. And now I think that is that [19:45] gap is shrinking. The other thing that's [19:47] interesting that's happening is the span [19:48] of control is changing. I've always [19:50] advocated for, you know, the the [19:52] degenerate case of where you have a team [19:54] of 400 engineers, you take the square [19:56] root of 400 and you have essentially 20 [19:58] direct reports, each having 20 direct [20:00] reports, and then it's just two layers [20:01] of management. Uh, but usually most most [20:04] organizations have people who have like [20:06] five or three reports. The most [20:07] degenerate case is the binary tree, [20:09] right? Two reports two reports, two [20:10] reports all the way down. Um, but I [20:12] think the span of controls will [20:13] increase. I think, you know, Tibo I [20:15] think talked about having 33 direct [20:16] reports. You know, Jensen talks about [20:18] having [20:18] >> 33, yeah. Yeah, yeah, having like 40 or [20:20] 50. Yeah, I think like [20:22] people will have more direct reports and [20:24] fewer managers. And managers will be [20:26] more connected with the code. I think [20:27] all of this is really a good thing. [20:29] >> as a follow, what about the traditional [20:30] career path? So, traditional, oh my [20:32] gosh, I'm talking like, you know, like [20:33] pre-like 2020, 2022 because we were used [20:35] to there was a career path, like be a, [20:37] you know, software engineer, senior [20:38] engineer, then either staff engineer or [20:39] engineering manager, senior engineering [20:41] manager, director, senior director, etc. [20:43] What do you think might happen just in [20:45] taking educated guess? [20:47] Well, first of all, um, you know, [20:49] anytime somebody asks me about career [20:51] path as an engineer, but the first thing [20:53] I tell people is, "Don't be a manager." [20:56] >> [laughter] [20:56] >> Um, you know, in fact, I did that myself [20:59] when I started out, somebody gave me [21:00] that advice. And so, the for the first [21:01] many years of my career, I avoided being [21:04] a manager as far as as [21:05] um, until I found decisions being made [21:08] that I didn't understand and so then I [21:09] hit bought my head up to see, okay, what [21:10] the hell is happening and that sort of [21:11] thing and then joined the dark side. But [21:13] like, um, you know, Well, it worked out [21:15] pretty good in the end. [21:16] >> Yeah, yeah, yeah. But, uh, I'd say like, [21:18] you know, for for engineers like, I [21:20] mean, it's it's it's a great time to be [21:22] alive, right? I would just write code, [21:24] use agents, figure this out, do all all [21:27] the advanced, you know, cutting edge [21:28] stuff. [21:29] For a while, I mean, we don't know where [21:31] the future's going, but like, you'll be [21:32] fine if you're an engineer writing code. [21:34] Managers and leaders, uh, it's a little [21:36] tougher. I think there might be fewer of [21:38] them. I think, uh, it's exciting if you [21:40] are want to be hands-on, then it it's [21:41] amazing. [21:43] Um, I think there's less of like [21:44] leadership, management, blah, blah, [21:46] blah. It's more of like doing and like [21:48] figuring things out in this new world. [21:49] And those who do, I think will do well. [21:51] Those who want to like stick to the old [21:52] career paths might have to find [21:55] something else. [21:57] I have three things. One, number one, [21:58] for all the startup founders, every time [22:00] an investor asks you, "How are they [22:01] preventing the incumbent doing the same [22:03] thing that you're doing?" Just tell them [22:04] that the CTO CTO of Atlassian had to buy [22:06] a laptop on his own money to start [22:08] coding. [22:10] That's the best answer I can give [22:11] because it shows you how even, you know, [22:14] relatively agile companies that actually [22:16] develop agile tools, [22:18] you know, can't really do what you can [22:19] do in 5 minutes. [22:21] Um, All right, I'll I'll I'll fix it. [22:23] I'll fix it once I acquire a company, [22:24] Thomas. [22:25] >> [laughter] [22:26] >> Or you can you can get their assets. You [22:28] can get their assets and use them for [22:29] coding. Um, number two is I think what [22:32] happened in the last 2 years, uh, [22:35] through, um, coding agents like Copilot, [22:37] Cursor, and Devin, is that [22:39] many CTOs and CIOs, even in the largest [22:41] banks in this country and many other [22:42] countries, have realized they can go [22:44] back to coding because it no longer [22:45] takes hours to install all the packages [22:48] and figure out all the problems. And so [22:50] I have actually I have friends in that [22:51] in that space that told me stories of [22:53] like on every night they would give [22:55] Devin a task and and say, "Devin, build [22:57] me this." And then in the morning we'll [22:58] check it the check in with the developer [23:01] at the agent and then I keep going that [23:03] way and then they have their normal [23:05] day-to-day as a as a CTO of of a big [23:07] bank. And you do that for 2 weeks and [23:09] you realize everything is going to [23:11] change and has to change in my [23:12] organization and in contrast to the you [23:15] know Twilio founders ask your developer [23:18] where the developer decides bottoms up [23:19] what the tools are, those folks went [23:21] into the into the organization says, "I [23:22] don't want to hear any excuses. We're [23:24] going to roll out agents." And you know, [23:26] um many banks still are on very archaic [23:28] systems and they have developers like [23:30] going to Citrix and and what have you [23:32] and often the CTO was not empowered to [23:34] override this because of CISO concerns [23:36] and and what have you and I think that [23:37] has dramatically changed because we're [23:39] basically getting our hands dirty again [23:41] and realize how powerful this technology [23:43] is and that shift is happening and you [23:44] see that everywhere. Like no other [23:46] software development technology has been [23:48] adopted as fast as agents, right? Like [23:50] most German companies, you know, [23:51] Japanese companies, other international [23:53] are still not in the cloud uh because of [23:55] all the kinds of concerns that they [23:56] heard from the legal team, security [23:57] teams and so on and so forth. [23:58] And then there's the third piece you [23:59] know you asked about leadership and [24:00] manager. You know, when I became a [24:02] manager um the first time I became [24:04] really a manager was when I my startup [24:05] got acquired by Microsoft because CEO of [24:07] a 10-person startup you're not actually [24:09] a manager, you're just one of 10 and [24:11] you're the speaker and then has to do [24:12] payroll and and and pitch to customers. [24:15] And I became a manager and I realized [24:17] oh god, now I have to hire people which [24:19] means I have to write a job description [24:20] and do interviews and I have to write [24:22] performance reviews you know and when [24:24] ChatGPT came out all of a sudden we just [24:26] would ask ChatGPT to write the [24:27] performance review for us [24:29] and of course the employees did the same [24:31] on their side and if you have worked at [24:33] Microsoft, every like the employee has [24:35] to fill out like I think seven input [24:37] fields on their side and then the [24:39] manager has to react to those seven [24:40] input fields and if you're [24:42] a lazy developer manager, you'd write I [24:44] agree with you and the employee is not [24:46] happy about that. Hang on. [24:47] >> so you kind of hacked that system by [24:49] just asking ChatGPT which then in [24:51] reverse is then give me just the bullets [24:52] that you put into ChatGPT so at least I [24:54] know how you're prompting. [24:56] >> [laughter] [24:57] >> So you became the CEO of GitHub with [24:59] this mentality? [25:01] >> [laughter] [25:03] >> You know that God loves GitHub. [25:04] >> the You know the the the key [25:07] um the key I know pragm if you will or [25:10] dogma. [25:11] >> [laughter] [25:12] >> Um by the way, we were joking in the [25:13] green room. I think the next one is the [25:14] dogmatic summit. And so, we have all the [25:16] dogmas on stage. It's much more [25:18] entertaining, I think. Um [25:20] it's developers first, right? Developers [25:22] first is what what we always said at [25:23] GitHub for everything we design for [25:25] every process for the marketing. And [25:26] when we fail, um you can see that a [25:28] hacker news very very straight, right? [25:30] Like when a GitHub blog post or GitHub [25:32] tweet or a message is too corporate, [25:35] {quote} {unquote}, developers won't like [25:36] that. And they don't have that um give [25:38] me the truth. Give me the direct [25:40] conversation. Don't give me all the [25:42] marketing bull. That works for other [25:44] products, but it doesn't work for [25:45] developer tools, right? And I think the [25:47] same is true for being a people manager [25:49] a [25:50] an engineering manager of a team. Like [25:52] your team knows exactly whether you're [25:53] talking straight to them and giving them [25:54] the truth or whether you're sugarcoating [25:56] that they actually are doing so well and [25:58] you're kind of like trying to tell give [25:59] them the message that you either improve [26:01] or you get the out, right? And And [26:04] And I think this is where, you know, the [26:06] AI is changing this because this I'm [26:09] spending an hour of writing a a [26:11] prettified, you know, summary of a [26:13] performance. Of course, the engineer [26:15] just feeds that into ChatGPT backwards [26:17] and says, "What did Thomas actually [26:18] mean? And did he use AI to write this?" [26:21] And all of that. And I think this is is [26:22] a good thing. Like, you know, when we [26:24] when we think about um AI-driven sales [26:26] processes, hell, I don't want an AI [26:29] email from a sales [26:30] from a sales agent to sell me some [26:32] outsourcing company or something like [26:34] that. Just I want an AI that deletes all [26:36] that and tells them to never contact me [26:38] again. When And I think the same is true [26:40] like for people management, it's so much [26:42] more so much more enjoyable when you [26:44] have a relationship with your with your [26:46] with your team members I see that's on [26:48] an honest trustworthy basis. Like you [26:50] hopefully have, you know, with your [26:51] spouse at home and and your kids and [26:52] whatnot. And I think that is going to [26:54] shift because you can no longer cheat [26:56] your way as a people manager into being [26:58] the nicest manager of everybody while in [27:00] reality uh you're you're having uh [27:02] you're you're struggling with all the [27:03] problems in your team. [27:05] I mean, you heard it from the former the [27:07] the last CEO of of GitHub, your manager [27:10] might actually become like a bit more [27:11] enjoyable. Thanks for that. [27:14] Looking at your current teams now, what [27:17] is the biggest change that's already [27:18] happened in in how you're working and [27:21] what do you expect to happen this coming [27:22] year? [27:25] Yeah, I I mean, like clearly the biggest [27:26] change is agent decoding and using um [27:29] agents to do stuff like in Atlassian, [27:31] Robo Dev is used by all our engineers. [27:34] Um not [27:34] >> All all the engineers? [27:35] >> Yes. Yes. [27:36] >> Nice. Yes. Uh code reviews, I mean, [27:38] every day I see the percentage of, you [27:40] know, diffs that are through code [27:41] reviews are increasing quite a bit. [27:44] Um PRs per engineer have gone up 89%. [27:47] Issue cycle time has gone has gone down [27:49] 42%. 51% of security vulnerabilities are [27:53] now caught through agents. So, we're [27:55] seeing like massive change in in our [27:58] productivity output metrics, the Dora [27:59] metrics, all of that is going up, you [28:01] know, is going well, up meaning well. [28:04] Um [28:05] because of agent decoding and that sort [28:06] of thing. And uh more than the metrics, [28:09] I'd say like we are we are really [28:11] excited about how we are working across [28:13] PM and design and engineering because we [28:16] build a lot of products like Jira [28:17] Confluence and so that that loop is very [28:19] important for us. And we're finding that [28:21] because uh PMs are using like Replit and [28:23] things like that, they're producing [28:24] actually better specs that are much more [28:27] uh amenable to being close to the [28:28] product that we want, easier for [28:30] engineers to go implement. And so, [28:32] definitely seeing a lot of change. What [28:33] will happen in the future, I think, is [28:36] um this notion of building products with [28:38] actually zero lines of code manual [28:41] coding, I would say. Uh because today [28:42] it's a mix of like some manual coding, [28:44] some agents. Um [28:45] I think we will get to the point where [28:47] we just trust the code reviews done by [28:49] the agents and not have to have too much [28:51] human review over that. [28:53] I think we move towards more [28:55] verification of inputs and outputs to [28:57] see the system performing according to [28:58] the right security reliability [29:00] performance bars, less about inspection [29:02] of code. And then if I were to look out, [29:04] I know that Tibor didn't want to look [29:05] out 2 years, but if I were to look out 2 [29:07] years, [29:08] plus [29:09] maybe we don't have programming [29:11] languages and IDEs anymore and we have [29:13] some kind of AI JVM or something that [29:16] just sort of does things and because of [29:18] like if you think about it, programming [29:20] languages are there because like, you [29:22] know, we don't want to write assembly [29:23] and we need something to tell the [29:24] computer what to do. But like if AI is [29:27] able to do that and you know, you're [29:29] able to debug cells using AI as well, [29:31] then it shifts to a higher level intent [29:33] and you don't need maybe programming. [29:34] Now that's super extreme. I don't know [29:36] if it'll go there, but it is conceivable [29:39] and so that's really exciting to think [29:40] about what that world look like. [29:43] From the CEO perspective, I think [29:45] there's two [29:47] drastic changes. One is [29:49] cost are through the roof. [29:51] And as everybody who manages a larger [29:52] team has some fixed opex budget [29:55] that is you know, mostly your salaries, [29:57] your benefits and then some travel and [29:59] expenses, right? All of a sudden we have [30:00] flexible token costs and the more [30:02] productive you had all these impressive [30:04] statistics, the more productive your [30:06] developers are, the more your costs are [30:08] going through the roof and you actually [30:09] create an inversion where you have to [30:11] slow down some developers because [30:12] they're burning so many tokens and then [30:13] they're like, well then build build less [30:15] features, right? And that's something [30:16] that a startup founder only deals with [30:18] when when the money runs out the run [30:20] rate gets shorter, but a [30:22] big manager in a in a corporation will [30:24] actually have to figure out with their [30:25] with their finance team, right? [30:26] What the traditional approach to this [30:28] will no longer work. And you actually [30:30] want to encourage teams to burn more [30:31] tokens. And you talked in the very early [30:33] session this morning about opening eyes [30:35] billions tokens and they don't have to [30:37] pay for them. Always that's not true. [30:38] They're paying for the GPUs to to Azure [30:41] and and Oracle and and whatnot. But [30:43] that's I think a a drastic change to how [30:45] we're managing teams and that all of a [30:47] sudden you had and look what nobody [30:49] wants to do is fire people to offset the [30:51] cost of the tokens, right? Because the [30:53] the the human cost of that is is may [30:54] higher than the benefits. Think the very [30:57] positive version of that is coding is [30:59] fun again. And I you know, I learned [31:00] coding on a Commodore 64 in the early [31:03] 1990s and then I had a and then a [31:05] Pentium [31:08] and whatnot and I remember the days when [31:10] I couldn't solve any of my problems [31:11] because all I had was books and computer [31:13] club was only Wednesdays and you were [31:15] just stuck, right? And you went to bed [31:16] frustrated and and and in the morning [31:19] hopefully you had some, you know, [31:21] intuition of how to solve that problem. [31:22] Came the internet, came forums, all of a [31:24] sudden you could talk to people. Now you [31:25] can just in 3 seconds, you know, ask the [31:27] agents to figure it out and I think, you [31:29] know, we're underestimating the power of [31:31] these agents because we all think about [31:33] code generation. I think the best [31:35] scenario is actually I have some stupid [31:37] build error or NPM error or something [31:38] like that on the terminal and just feed [31:40] that into Codex and say go and solve [31:42] this. I don't want to deal with any of [31:43] that. But I think that's it's way more [31:45] fun than it ever was. Same for the unit [31:47] testing. Raise your hand if you love [31:48] writing unit tests, right? Like oh, [31:50] there's the one. Um [31:54] I'm looking for Kent back. No, that the [31:56] the exception to the rule, right? But [31:57] like that that's so powerful to just say [31:59] write write me unit tests and and or fix [32:02] the tests and and and and and what have [32:03] you. Coding is fun again and it brings [32:05] us back to when we learn coding. I think [32:07] what agents have done is it brings us [32:08] back to the joy of coding and I was at [32:11] OpenAI a month ago or so and they showed [32:14] a couple of builders the new Codex Mac [32:16] app [32:17] and made sure we were all under NDA, but [32:19] now the app is out so I can talk about [32:20] it. And was a bit, you know, food and [32:23] and presentation and then we all had [32:25] some coding time and I built three [32:26] native Mac apps like in Swift UI without [32:29] ever looking at the code, right? And and [32:31] that's just and I had a menu bar app and [32:33] somebody was yesterday on X saying, "I [32:34] love building menu bar apps on on Mac," [32:37] right? And it's so easy and if you ever [32:39] tried that yourself and and going on, [32:41] you know, GitHub, Google, Stack [32:43] Overflow, whatever, have it even setting [32:44] up just the Xcode project to hide the [32:46] dock icon and have it only in the menu [32:48] bar, you you you have given up and and [32:50] the idea has, you know, flown away by [32:52] the time you actually had the first [32:54] build running. And I think that's just [32:55] so incredible and whether that is [32:57] applied to all our hobby projects which [32:58] ultimately got us in this profession, [33:00] hopefully, [33:01] whether or it's you know, doing work at [33:03] Atlassian or entire GitHub. I think [33:05] that's what what is so amazing about [33:07] this and that is the actual drastic The [33:10] productivity is great, you know, for the [33:11] CFO and the CEO and the [33:14] public stock market, but what really [33:16] matters to us is our job is fun again. [33:20] 100%. And I I I love that. So, thank you [33:23] so much Rajiv and Samarth and especially [33:26] for that nice ending. This was great. [33:27] Thank you. Let's give a round of [33:28] applause to them. [33:30] >> [applause] [33:31] [music]