Thomas Dohmke (cofounder & CEO of Entire, former CEO of GitHub) and Rajeev Rajan (CTO of Atlassian) discuss what it means to build world-class engineering teams in the age of AI, drawing on their experience leading large developer-focused organizations and now, in Thomas’s case, starting a new company. The conversation covers how AI-native teams actually work day-to-day, how roles are collapsing and shifting, what happens to management and career paths, and why coding has become fun again.
What AI-native teams look like
Rajeev describes AI-native teams at Atlassian as those where engineers write zero lines of code manually — everything is done through agents and agent orchestration.
The lines between PM, design, and engineering are blurring: PMs and designers are writing code, leading to more creativity and faster iteration.
Teams aren’t necessarily getting smaller, but they’re producing 2x to 5x more output.
The key question isn’t “how do we do more with fewer people?” but rather “what can we create now that we couldn’t before?”
Thomas draws an analogy to cloud native: the term was coined after the fact, and what we call “AI native” today will look very different in a few years.
His own children represent the truly AI-native generation — they use tools like Adobe Firefly without being taught, the way previous generations learned Google.
He’s candid that much of the “AI-native life” narrative is overstated: he still deals with HR systems, board insurance forms, and hundreds of inbound emails that no agent can handle.
The real crux: yes, agents write code, but the collaboration layer (specs, communication across languages and time zones) remains unsolved. Writing a feature spec in English when English isn’t your first language is genuinely hard, and programming languages partly solved this by limiting vocabulary — markdown docs don’t.
How teams are actually using agents day-to-day
The biggest workflow change: developers force themselves not to look at the code. They start with a prompt and a reasoning process, and only engage with code through agent outputs.
Code review is shifting: instead of reading line by line, developers use tools like Cursor to point out mistakes. The next step is having code review agents work directly with coding agents, removing the human bottleneck.
Thomas sees the most AI-native developers as those who’ve mastered this orchestration — it’s a skill in itself, and it up-levels humans rather than replacing them.
Rajeev frames the shift as moving bottlenecks to “left of code” and “right of code”:
Left of code: Planning and spec-writing. Atlassian uses Confluence heavily — engineers and PMs put intent and specs in natural language, and agents read comments and execute.
Right of code: CI/CD, deployment, incident resolution. Agents handle SEVs and monitoring.
They call this the AI-native SDLC, covering ideation through production.
Internal coding agents: Robo Dev
Atlassian built its own coding agent called Robo Dev, used across the entire SDLC — code reviews, CI/CD, incident resolution.
It uses Anthropic’s model but beats Claude Code on SWE-bench by leveraging Atlassian’s proprietary teamwork graph — context about who works with whom on which PRs and issues in Jira.
The lesson: agents are only as smart as the context you give them.
Distributed teams and AI
Thomas’s startup Entire is distributed across Australia, Germany, Spain, Lisbon, and the UK — unusual for an early-stage company.
He’s a strong believer in remote work for personal happiness and 24/7 coverage — when it’s 6 PM in Europe, it’s noon in Melbourne.
The traditional disadvantage of remote work (loneliness, no one to ask questions) is mitigated by agents acting as always-available sparring partners — for brainstorming, writing ADRs, solving build problems, even implementing cookie policies in React apps in seconds.
This has evened out the competitive disadvantage compared to in-office AI companies in San Francisco.
Atlassian has been distributed-first since before COVID (“team anywhere”), but they maintain offices and believe in intentional togetherness.
Rajeev recalls being stuck at 2 AM in the office with no one to ask; now agents fill that gap, making distributed work significantly easier.
How roles are changing: engineering, PM, and design
Ownership is shifting from code to artifacts like Confluence, Jira, and Loom (video). Accountability is shifting toward verification — setting guardrails and checking inputs/outputs rather than inspecting every line of code.
Atlassian isn’t making radical structural changes to team roles yet. The focus is on unleashing creativity and doing more, not necessarily doing more with fewer people.
In some greenfield projects, they’ve achieved 10x to 100x productivity and reshaped teams accordingly.
Legacy codebases remain hard — Robo Dev can’t yet handle complex projects on old systems without significant effort.
Thomas sees a massive role collapse coming:
Product managers are becoming product engineers (expected to build prototypes with coding agents, not just write docs).
Designers are becoming design engineers.
Software engineers stay software engineers.
But it goes beyond engineering: marketers, comms people, and assistants are already using tools like Lovable and Repl.it to automate parts of their work.
The open question: how do organizations let everyone be a builder in a secure, trustworthy way?
What engineering leaders should do differently
Rajeev is excited that leaders can write code again — he bought his own laptop to bypass IT restrictions and build things with agents over the holidays.
This reconnects leaders with their teams and with the craft.
Span of control is increasing: Thomas and Rajeev both reference leaders like Jensen Huang and Tibo with 30-50 direct reports. Fewer managers, each more connected to the code.
On career paths:
Rajeev’s advice: “Don’t be a manager” — at least not until you need to understand decisions being made above you.
For engineers: it’s a great time to be alive. Use agents, do cutting-edge work.
For managers: it’s tougher. There may be fewer of them. The old career ladder is less relevant; the advantage goes to those who are hands-on and figure things out in the new world.
Thomas shares three observations about organizational change:
Even at Atlassian — a company that builds agile tools — the CTO had to buy his own laptop to code freely. That’s how hard it is for incumbents to move fast.
CTOs and CIOs at large banks are personally using agents (like Devin) at night, building things, and then mandating agent rollouts top-down — bypassing the usual CISO and legal objections. This top-down adoption is unprecedented in enterprise software.
Management itself is being forced toward honesty: when both managers and employees use AI to write performance reviews, the system breaks down, and what’s left is the need for direct, honest, trustworthy relationships — no more sugarcoating.
Future predictions
Rajeev’s near-term predictions:
Zero manual coding in the future — today it’s a mix, but eventually agents will handle code reviews and humans will focus on verification of inputs and outputs.
PRs per engineer at Atlassian are already up 89%, issue cycle time down 42%, and 51% of security vulnerabilities caught by agents.
Longer-term (2+ years): programming languages and IDEs might disappear entirely, replaced by something like an “AI JVM” — a higher-level intent layer where you don’t need to write code at all. Debugging happens through AI. This is speculative but conceivable.
Thomas’s near-term predictions:
Costs are through the roof: token costs are variable and scale with productivity. The more productive your engineers, the more they burn tokens. This creates a new management problem — you may need to slow down developers who are too productive because they’re too expensive. Finance teams will need new models.
Coding is fun again: agents eliminate the frustration of build errors, NPM issues, and setup problems. Thomas built three native Mac apps in SwiftUI without looking at code. Unit tests are generated on demand. This joy factor — getting back to why people learned to code in the first place — matters more than productivity metrics.
He experienced this firsthand at OpenAI with the new Codex Mac app, building menu bar apps that would have taken days of setup in minutes.
