The Pragmatic Engineer
AI-assisted summary of OpenAI: How AI is reshaping the craft of building software - The Pragmatic Summit — original source. Check the original for full context.
Source published:
Key ideas
- Internal software engineers at OpenAI routinely consume hundreds of billions of tokens per week by running autonomous coding agents on remote server environments called 'Codex Box.' (0:00)
- OpenAI continues aggressively hiring early-career software engineers and interns, bringing in a cohort of roughly 100 new grads who operate as 'AI-native' developers alongside flat management structures. (12:07)
- A single product manager supports the entire Codex engineering organization by using Codex agents to ingest testing feedback, create Notion specs, and automatically assign Linear bug tickets. (19:48)
- Leadership argues engineering organizations should reframe token consumption from infrastructure overhead into payroll calculations for synthetic 24/7 teammates. (22:52)
- OpenAI engineering leaders project that within six months, inference speeds will jump by an order of magnitude and multi-agent systems will be able to synthesize millions of lines of code from scratch within 24 hours. (25:45)
Detailed notes
## Background Published on YouTube by The Pragmatic Engineer on February 23, 2026, this recorded session from The Pragmatic Summit features Tibo Sottiaux (Head of Engineering for Codex) and Vijaye Raji (CTO of Applications at OpenAI). The discussion explores how internal engineering workflows, tooling, organizational structures, and daily software practices are being radically transformed by AI within OpenAI.
## TL;DR Vijaye Raji and Tibo Sottiaux detail how OpenAI engineers have transitioned from manual coding to orchestrating autonomous AI teammates across dedicated remote server environments ('Codex Box') that burn hundreds of billions of tokens per week. This massive acceleration has shifted traditional software bottlenecks away from code generation and toward code review, CI/CD pipelines, and high-level architectural guardrails. Rather than eliminating entry-level roles, OpenAI is actively hiring 'AI-native' new graduates while empowering PMs and designers to build production-grade prototypes directly. Ultimately, the speakers urge engineering leaders to view token expenditure as payroll for tireless digital colleagues and predict that multi-agent orchestration swarms and symptom-based debugging will become standard within months.
## Atmosphere & style The discussion carries an energetic, pragmatic, and slightly surreal vibe, as everyday engineering rituals at OpenAI—like dispatching background AI threads during live meetings to resolve data questions before the call ends—feel like scenes lifted straight out of science fiction. Gergely Orosz acts as a grounded, sharp sounding board, posing hard questions about junior skill erosion, gatekeeping, and mounting token expenses. Raji and Sottiaux answer with candid, unvarnished enthusiasm, pairing a twenty-five-year historical perspective on tech cycles with a palpable sense of awe at the blinding speed of the current transformation.
## Bulletin - [00:00](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=0s) Internal software engineers at OpenAI routinely consume hundreds of billions of tokens per week by running autonomous coding agents on remote server environments called 'Codex Box.' - [12:07](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=727s) OpenAI continues aggressively hiring early-career software engineers and interns, bringing in a cohort of roughly 100 new grads who operate as 'AI-native' developers alongside flat management structures. - [19:48](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1188s) A single product manager supports the entire Codex engineering organization by using Codex agents to ingest testing feedback, create Notion specs, and automatically assign Linear bug tickets. - [22:52](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1372s) Leadership argues engineering organizations should reframe token consumption from infrastructure overhead into payroll calculations for synthetic 24/7 teammates. - [25:45](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1545s) OpenAI engineering leaders project that within six months, inference speeds will jump by an order of magnitude and multi-agent systems will be able to synthesize millions of lines of code from scratch within 24 hours.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=0s) Coding tools have rapidly evolved from passive autocomplete utilities to autonomous agents and named teammates embedded in developer workflows. - [00:00](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=0s) Remote execution environments like 'Codex Box' decouple long-running agentic coding tasks from local developer machines. - [02:19](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=139s) Engineering bottlenecks continuously shift upstream as code generation accelerates, moving from coding to review, triage, user feedback synthesis, and product strategy. - [06:43](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=403s) Engineers increasingly resolve architectural debates by having agents build multiple working prototypes in parallel rather than writing lengthy speculative design documents. - [06:43](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=403s) Designers at OpenAI are now committing and shipping production code directly without needing dedicated software engineers to rewrite their implementations. - [09:37](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=577s) Codex runs autonomous overnight loops to conduct quality assurance, regression testing, and downstream model training with auto-generated PDF evaluation reports. - [09:37](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=577s) Unanswered telemetry questions during live meetings trigger 20-minute background Codex runs to return data before the discussion ends. - [12:07](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=727s) OpenAI is leaning heavily into hiring new graduates, viewing incoming junior engineers as AI-native talent rather than an obsolete tier of workers. - [12:07](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=727s) Flat team structures, such as a single manager overseeing 33 direct reports, are enabled by leveraging Codex as a primary onboarding mentor and architectural guide. - [15:56](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=956s) Concerns over losing foundational programming skills mirror past transitions from Assembly, C++, and pre-IntelliSense IDEs; higher abstractions shift leverage rather than dilute craftsmanship. - [18:25](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1105s) Human taste, product intuition, and user empathy remain irreplaceable differentiators even as PMs and designers increasingly write their own functional code. - [22:52](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1372s) Token expenditures should be budgeted against the business value of 24/7 digital teammates rather than restricted purely as raw compute costs. - [25:45](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1545s) The velocity and scale of the generative AI transition far outpace prior tech waves, rendering traditional two-year planning cycles unworkable. - [28:06](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1686s) Future engineering will focus heavily on enforcing system guardrails and verifying behavioral properties at the boundary rather than directly inspecting implementation code. - [28:06](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1686s) As system complexity deepens across layers of AI-generated software, debugging will shift toward diagnosing high-level emergent symptoms instead of step-by-step code execution. - [29:41](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1781s) Developer interfaces are expected to consolidate into a single personal assistant that orchestrates and summarizes the work of hundreds of underlying specialized agents.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=0s) Intro: What’s Changing Inside OpenAI
Vijaye Raji (CTO of Applications at OpenAI) reflects on how radically the software engineering environment has transformed over his first six months at the company. He explains that working alongside the frontier research happening internally makes projecting the near-future possibilities of software development truly mind-blowing. Writing code has undergone a fundamental transition: within half a year, tools like Codex have evolved from passive autocomplete helpers into ambient extensions, then into autonomous agents, and now into full-fledged teammates. Raji notes that engineers are even beginning to name their agents and treat them as working colleagues.
```mermaid flowchart LR accTitle: Evolution of Codex in the Developer Workflow accDescr: Progression from simple tooling to agent teammates handling dev work. A["Passive Tool"] --> B["Extension"] B --> C["Autonomous Agent"] C --> D["Teammate (Named Agent)"] D --> E["Codex Box (Remote Dev Box)"] ```
The scale of automated execution has reached unprecedented volumes within OpenAI. Raji shares that internal usage leaderboards reveal individual software engineers regularly burning through hundreds of billions of tokens per week. To support this demand, OpenAI launched an internal system called "Codex Box," which lets developers reserve remote server dev boxes to execute prompts independently. Developers orchestrate runs from their laptops, close the lid, step away to meetings, and return to find the implementation completed on the remote machine. As Raji summarizes this shift: “So I'll tell you this right, the way we write software has fundamentally changed.” He predicts that while this agentic workflow is currently concentrated at the heart of Silicon Valley, it will rapidly diffuse across the industry within months until it becomes the baseline standard for writing software.
- Internal OpenAI engineers routinely consume hundreds of billions of tokens per week executing agentic coding workflows. - "Codex Box" provisions dedicated server-side developer environments, freeing developers from running intense tasks locally on their personal machines.
---
[02:19](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=139s) How the Codex Team Works Day-to-Day
The host notes that while hearing about these workflows sounds like a fairy tale, candid conversations with unfiltered, non-media-trained engineers at OpenAI reveal that adoption varies across teams—not everyone writes 100% of their code with Codex yet. However, the Codex team itself acts as the vanguard, operating at the bleeding edge even compared to the rest of the company.
Tibo Sottiaux (Head of Engineering for Codex) describes the team's culture as a fast-evolving state where practices are reinvented almost week to week. As soon as one part of the workflow is automated, the limiting factor moves down the line:
```mermaid flowchart TD accTitle: Shifting Engineering Bottlenecks accDescr: Sequential movement of workflow bottlenecks from generation to upstream strategy. subgraph Execution ["Execution Stage"] A["Code Generation"] --> B["Code Review"] end subgraph Upstream ["Upstream Discovery Stage"] B --> C["Triage & Bug Tickets"] C --> D["Synthesizing User Feedback<br>(Twitter, Reddit)"] D --> E["Translating Signals into Product Strategy"] end ```
The team now uses agents to ingest sentiment and feedback across external surfaces like X (formerly Twitter) and Reddit, triage incoming tickets, and synthesize that unstructured user data directly into product strategy. Sottiaux recounts a recent hiring interview where a candidate negotiating an offer asked how much personal compute allocation they would receive to build products—a perk traditionally reserved solely for machine learning research scientists training frontier models. As Sottiaux puts it: “So I think there's like this shift there where you know people realize you can hyper leverage yourself in you know all sorts of like novel ways and if you do have great taste, great ideas, you know how to build software, it's like you know what a time to be alive really.”
---
[04:52](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=292s) Product Engineering and the Creative Feedback Loop
Stepping back to examine product engineering across OpenAI as a whole, Raji emphasizes that despite the automation wave, software is still built for human beings. Because of that, core human product intuition remains irreplaceable. Using tools like the 1Password desktop app workflow and new accessible interfaces to experiment, engineers still have to conceive the target product vision and continually iterate on the details. While agents might one day build products for other agents—and perhaps step into the product manager role when that happens—today's engineering value still hinges on human taste.
At the same time, the day-to-day experience of programming has become markedly more rapid and fun because the latency between having an idea and seeing it function has collapsed. Raji shares an anecdote about coding on an airplane without access to remote dev boxes: when flight attendants asked passengers to close laptops for takeoff or landing, he resorted to keeping the screen propped open just a crack under the tray table so the agent's run wouldn't terminate mid-stream. The host jokes that half the tech industry now walks around corridors with laptops propped slightly open to avoid breaking long-running agent threads. For Raji, this rapid cycle is liberating: “I actually think it's more fun now building software because the gratification cycle is so much shorter, and it's so really cool to see the product that you're building, test it, verify it, and then go back to Codex.”
---
[06:43](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=403s) New Engineering Practices and Emerging Bottlenecks
As engineering norms adapt to agentic workflows, traditional development rituals are being replaced by unconventional practices. Sottiaux points out that engineers historically resolved difficult architectural trade-offs through lengthy design documents, debating hypothetical alternatives on paper before discarding them. Today, engineers instruct agents to build multiple distinct architectural implementations simultaneously in parallel, evaluate the concrete working prototypes side by side, and move forward with the proven winner.
Role definitions are also breaking down. Designers are now committing and shipping more production code than traditional engineers did six months prior, because model generation quality has risen to the point where design-driven code can be merged directly as-is without requiring an engineer to rewrite it.
Raji adds that agents have largely eliminated the friction of obscure tooling syntax, such as parsing arcane `ffmpeg` command-line flags when processing media. Yet clearing these micro-hurdles inevitably exposes larger systemic pipeline constraints:
```mermaid flowchart LR accTitle: The Shifting Production Pipeline Bottlenecks accDescr: How accelerating individual coding speeds causes downstream workflow queues. A["5x Individual Coding Velocity"] --> B["Code Review Backlog"] B --> C["Security & Compliance Checks"] C --> D["CI/CD Integration & Deployment Pipeline"] ```
As Raji explains: “Once you solve coding, for example, now you've just made every engineer five times more productive. What's going to happen is like there's going to be more code being written, which means that code reviews will become the bottleneck, and then after code reviews, integrations and deployment CI/CD will become the bottleneck.”
Addressing how the Codex team is moving past the paradigm of short autocomplete snippets, Sottiaux highlights the emergence of autonomous overnight runs. Rather than restricting models to ten-minute micro-tasks, the team provides agents with rich environments and self-testing harnesses, enabling them to execute continuous problem-solving runs for hours on end without human intervention.
[09:37](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=577s) Autonomous Testing, AI Training AI, and "Sci-Fi" Meeting Loops
Tibo Sottiaux explains how Codex has evolved into an engine capable of running long, fully autonomous loops that previously required constant human oversight. For quality assurance, the team runs Codex overnight to autonomously test itself, executing endless QA passes and flagging code regressions before engineers return in the morning. Even more startling is its role in core research: Tibo recounts regular conversations with the team’s model-training researcher, who finds himself continually humbled by the agent's capabilities. When the researcher initially believes a task requires human intervention, he repeatedly discovers that Codex was fully capable all along—it had simply been prompted suboptimally or configured without the right setup. Tibo describes the emotional whiplash of watching an AI independently train downstream models and write structured summary reports, remarking: “And you know this is both exciting and a little bit depressing at the same time.”
Gergely Orosz remarks that the Codex team's internal workflows sound like scenes straight out of science fiction—specifically how live team meetings trigger background AI agents to resolve debates in real time. Tibo confirms this dynamic, pointing to their weekly analytics reviews covering feature adoption, retention curves, and funnel performance. Whenever an open question arises that is not answered by existing telemetry dashboards, the team does not push it to next week's backlog. Instead, the data analyst fires off a background Codex thread right at the start of the session. While the team discusses other topics for twenty minutes, the agent dives into the data and returns with answers in time for the final ten minutes of the meeting. Rather than halting discussions to gather data manually, the team treats Codex as a squad of on-demand analysts working silently in the background, a workflow that also carries over directly to incident response to diagnose outages and identify the fastest path to production recovery.
```mermaid flowchart TD accTitle: Codex In-Meeting Analytics Loop accDescr: Diagram showing how unanswered product analytics questions in team meetings trigger background Codex threads that deliver answers before the meeting concludes.
subgraph Meeting["Weekly Analytics Review"] A["Team analyzes funnel,<br/>adoption, and retention"] --> B{"Unanswered question<br/>not in dashboard?"} end
subgraph CodexBackground["Autonomous Codex Execution (~20 Mins)"] B -->|"Fire off Codex thread"| C["Query raw telemetry<br/>and diagnose data"] C --> D["Synthesize findings<br/>and insights"] end
subgraph WrapUp["Meeting Conclusion (Last 10 Mins)"] D --> E["Present answers to room"] E --> F["Team debates solutions<br/>and decides next steps"] end ```
- **Autonomous Model Training Reports**: The model conducts unsupervised training runs, evaluates performance, and outputs a formatted PDF report containing findings and suggested avenues for human researchers to iterate on. - **On-Call Acceleration**: When an incident fires or an engineer is paged, Codex acts as an interactive co-pilot, surfacing root causes, parsing system state, and generating recovery paths within minutes.
---
[12:07](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=727s) The "AI-Native" New Grads and Flat Team Dynamics
Addressing an ongoing industry debate over whether entry-level roles are being rendered obsolete by senior engineers wielding AI agents, Vijaye Raji reveals that OpenAI is aggressively moving in the opposite direction. OpenAI is actively hiring early-career software engineers straight out of college alongside a rapidly expanding internship program. Vijaye rejects the pessimistic view that juniors are squeezed out, arguing instead that graduates entering the workforce today represent an entirely new paradigm of engineers who think and operate with models intuitively from day one. Looking ahead to welcoming an incoming class of approximately one hundred new grads, Vijaye Raji summarizes his conviction: “I actually truly believe that the new software engineers that are being created are going to be AI native.”
``` "I actually truly believe that the new software engineers that are being created are going to be AI native." — Vijaye Raji ```
On the Codex engineering team specifically, onboarding takes place inside an unusually wide and flat organizational hierarchy. Tibo manages 33 direct reports, deliberately eschewing middle layers so management never becomes an operational choke point for engineers shipping at high velocity. When new hires arrive, their primary onboarding mentor is Codex itself: they query the agent to inspect architectural conventions, navigate unfamiliar repos, trace existing work, and receive daily progress summaries. Crucially, the human side of onboarding is handled by whoever joined the team most recently, ensuring that cultural norms and documentation stay fresh. Tibo highlights a new graduate named Ahmed who joined six months prior and has completely outpaced expectations, playfully joking about his own cognitive decline compared to the unbounded energy and peak mental agility of fresh graduates thriving in an agentic coding environment.
- **OpenAI New Grad Cohort**: OpenAI is welcoming a summer class of roughly 100 new college graduates and interns specifically prepared to work alongside AI tooling. - **Flat Organizational Span**: Tibo maintains 33 direct reports across the Codex team to avoid managerial bottlenecks, betting on high autonomy and automated scaffolding over bureaucratic approvals. - **Self-Directed Onboarding via AI**: New team members ramp up by prompting Codex directly about codebase mechanics and design rationale rather than relying purely on static wiki documents.
---
[15:56](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=956s) Engineering Foundations and the Shifting Stack of Abstractions
When Gergely plays devil's advocate—asking whether new developers who rely heavily on AI generation risk missing out on the core foundational skills that senior engineers spent decades honing—both Tibo and Vijaye push back on the idea that fundamentals are disappearing. Tibo explains that architectural rigor, codebase guardrails, and human code review remain paramount. Codex does not operate with free rein; human engineers establish the broader boundaries, define modular constraints, and scrutinize structural health. When thoughtful software architecture and guardrails are set up in advance, junior engineers absorb the codebase's patterns rapidly and operate with remarkable precision rather than producing chaotic spaghetti code.
Vijaye frames the anxiety around AI assistants as the latest iteration of a cyclical panic he has witnessed throughout his 25-year software career. Recalling his days at Microsoft building the Visual Studio code editor and language services, he remembers when IntelliSense was first introduced and veteran programmers insisted that real developers should never rely on autocomplete popups. The same gatekeeping arguments played out previously when developers transitioned away from Assembly language, moved past manual memory management in C++, or began relying heavily on JavaScript frameworks. In Vijaye's view, higher levels of abstraction do not erode real software craftsmanship; they simply shift where engineering leverage is applied. Emphasizing what actually preserves long-term engineering excellence, Vijaye Raji concludes: “The point is that as long as you have the strong foundations, as long as you have product intuition, know what you're building and be able to like go down up and down the stack to be able to like solve problems, those are going to be the more important ones.”
| Historical Shift | Veteran Skepticism at the Time | Long-Term Reality | |:--- |:--- |:--- | | **Assembly to Higher-Level Languages** | "Real programmers write raw machine instructions." | Higher productivity allowed orders-of-magnitude larger software systems. | | **C++ to Managed Runtimes & JS** | "Abstracted memory and scripting languages aren't serious engineering." | Software eating the world across web, mobile, and distributed cloud systems. | | **Raw Editors to Visual Studio IntelliSense** | "You're not a real developer if you need an autocomplete dot prompt." | Became an indispensable baseline standard across every modern IDE and language server. | | **Manual Coding to AI-Native Agents (Codex)** | "Relying on agents will destroy foundational engineering skills." | Shifts focus toward systems architecture, taste, product intuition, and full-stack problem-solving. |
[18:25](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1105s) The Evolving Roles of PMs and Designers
When asked whether the acceleration of feature development is blurring the lines between engineering, product management, and design, Vijaye Raji dismisses the notion that these disciplines are becoming obsolete. At their core, products are created by humans for human consumption, meaning that human taste, product judgment, and design sensibility cannot be mechanically swapped out for an algorithm. Instead of facing replacement, product managers and designers are experiencing an upward shift in abstraction and productivity. Rather than handing off static Figma files or prose specs, designers and PMs are increasingly writing code themselves, translating interface ideas into interactive, working prototypes to validate assumptions before engineering teams ever get involved.
This shift extends well beyond writing code for the core application. Team members outside of engineering are repurposing tools like Codex to supercharge their day-to-day office workflows, utilizing custom plugins and prompts to generate PowerPoint decks, model data in Excel, and automate operational tasks. Across the board, the baseline of individual productivity is climbing, enabling non-engineers to express their intent through software directly rather than acting purely as coordinators.
As Vijaye Raji summarizes this enduring human element: “I go back to the as long as we're building products for humans to use, we will need human designers, we will need human product managers.”
- Product sense and design sense remain fundamental human differentiators that AI abstractions do not substitute. - Designers and PMs now write code and build production-grade prototypes to validate concepts prior to handoff. - Codex adoption has spread across non-engineering disciplines to automate tasks like assembling presentations and managing spreadsheet workflows.
---
[19:48](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1188s) Rapid Knowledge Diffusion and the Hyper-Leveraged PM
Because OpenAI ships models and tools to the public almost immediately after validating that they work, internal teams have only a fleeting window of foresight compared to the broader tech community. To prevent good practices from siloing, the company prioritizes high-velocity knowledge diffusion through company-wide hackathons, demo days, and active Slack channels dedicated to Codex usage and "hot tips." Tibo Sottiaux emphasizes that there is currently no single dogma or "one true way" to work with generative AI, making active experimentation and cross-team sharing essential.
```mermaid flowchart TD accTitle: Bug bash automation workflow accDescr: Diagram showing how Codex automates Alexander Embiricos's bug bash process from feedback collection to ticket dispatching. subgraph Input ["1. Team Testing"] A["1-Hour Bug Bash"] --> B["Raw Feedback from Testers"] end subgraph Synthesis ["2. AI Aggregation"] B --> C["Codex Agent"] C --> D["Structured Notion Spec"] end subgraph Execution ["3. Ticket Dispatch"] D --> E["Codex Agent"] E --> F["Linear Bug Reports"] E --> G["Feature Improvement Tickets"] F --> H["Assign & Follow Up with Engineers"] G --> H end ```
To demonstrate the extent of leverage possible, Tibo highlights Alexander Embiricos, the sole product manager supporting the entire Codex engineering organization. During a recent pre-release bug bash, Embiricos ran a one-hour live testing session, dispatched Codex agents to collect feedback across participants, compiled the findings into a Notion workspace, and then had Codex automatically file distinct bug reports and improvement tickets in Linear. The agents assigned the issues to the appropriate engineers and handled direct follow-up tracking, allowing a single PM to perform the operational workload of a massive program management office. Vijaye adds that this heightened capability is evident in company demo days: rather than showing superficial prototypes, hackathon participants now present deep, fully realized implementations that comprehensively handle edge cases from day one.
Describing how product managers must scale alongside engineering throughput, Tibo Sottiaux observes: “Your product manager cannot become the bottleneck so it's like you know you need to look at it in a principled way.”
- Internal channels like `#hot-tips` and Codex-focused Slack groups function as rapid clearinghouses for emergent AI workflows. - Alexander Embiricos operates as the lone product manager for the entire Codex team by turning Codex into an autonomous program management assistant. - Internal hackathons and demo days have shifted from proof-of-concept showcases to fully usable applications with comprehensive edge-case handling.
---
[22:52](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1372s) Navigating Token Costs and the Economics of AI Teammates
While OpenAI employees enjoy the privilege of unlimited, cost-free model inference, external engineering organizations must balance their ambitions against steep API bills and subscription limits. When asked how budget-constrained teams should approach adoption, Vijaye argues that the prevailing economic mental model must shift from treating tokens as infrastructure consumables to evaluating them as payroll for synthetic colleagues. If an autonomous agent operates around the clock, accepts Linear or Jira tickets, and reliably executes assigned engineering tasks, the governing calculation is no longer the token price, but what an organization is willing to pay to furnish every engineer with a squad of four or five tireless junior teammates.
Tibo builds on this economic reframing by pointing out the hidden cost displacement that AI enables. Broad operational sweeps—such as conducting exhaustive market research or having a squad of 15 engineers manually comb through an entire product backlog to identify trivial implementations—once required substantial headcount allocation, but can now be completed for a negligible token expenditure. While recognizing that early-stage startups or budget-conscious enterprises cannot always provide unrestricted inference across the board, Tibo cautions against premature austerity, urging leaders to grant their top performers substantial inference allowances so they can uncover the frontier of leverage.
Reframing the debate around model pricing, Vijaye Raji states: “And then the question then becomes like you know how much will you pay this teammate not necessarily like how many tokens are you going to use.”
- Model usage should be calculated against the output value of a 24/7 digital teammate rather than raw compute overhead. - AI drastically reduces the cost of large-scale engineering triage, replacing multi-engineer backlog audits with near-instant automated sweeps. - Prematurely throttling inference budgets for high-leverage engineers poses a strategic risk to organizational velocity.
---
[25:45](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1545s) Unprecedented Speed and Predicting the Next Six Months
Reflecting on his quarter-century career in the technology sector, Vijaye contrasts the current generative AI wave with historical disruptions, including the dot-com crash during his college years, the Y2K scare, the mobile app explosion, and the social networking boom. While each of those milestones brought intense industry realignment, Vijaye stresses that the present shift stands apart due to its sheer scale and velocity, remarking that modern adoption and capability curves represent anomalies where historical benchmarks no longer make sense.
When invited to forecast what software engineering and engineering management will look like two years down the road, Tibo rejects the two-year timeframe entirely, arguing that the industry is moving far too quickly to see that far ahead. Looking out merely six months, however, he expresses strong conviction in two near-term breakthroughs: inference speeds will jump by another order of magnitude, and robust multi-agent orchestration networks will reliably collaborate on massive objectives. Tibo anticipates that in the near future, an engineering team will be able to issue a high-level prompt—such as rebuilding an entire web browser from scratch—and receive millions of lines of functional, complex code back within 24 hours, fundamentally transforming human comprehension and maintenance of software codebases.
Offering his perspective on the historical uniqueness of this transformation, Vijaye Raji remarks: “I don't think I've ever seen anything like this.”
- Vijaye rates the current AI wave as substantially faster and broader in scale than the dot-com era, Y2K, mobile, or social networks. - A two-year planning horizon is considered unworkable given the current acceleration of AI capabilities. - Within six months, model execution speeds are projected to increase by another order of magnitude. - Emerging multi-agent networks are expected to tackle massive architectural goals autonomously, such as synthesizing multi-million-line software projects within a single day.
[28:06](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1686s) Guardrails, Rising Abstractions, and Debugging by Symptoms
As the craft of software development evolves, engineers will spend less time inspecting code directly and far more time defining the boundaries within which systems operate. Tibo Sottiaux explains that the industry will increasingly set guardrails around what gets built, enabling developers to validate correctness and enforce security properties simply by examining inputs and outputs. Code itself will be abstracted away, allowing developers to direct their attention toward high-level system properties and core engineering challenges rather than implementation mechanics. As Tibo describes it: “I think what we'll start seeing is we will set guard rails around you know what is getting built so that you don't actually have to look at the code anymore more and you can sort of either prove that it's correct in some way or the it is constrained in a way where you know it is secure and you can just look at the inputs and outputs and then code will become like abstracted away and it will all become about you know what are the actual challenges and things and you know the the properties of the system.”
Vijaye Raji points out that software engineering has always progressed by layering abstractions, allowing teams to deliver massive amounts of working product while writing relatively little low-level code. What makes the current moment unique is that the rate of change and abstraction has accelerated dramatically. However, this runaway complexity introduces a real engineering risk: when software accumulates too many sophisticated layers, diagnosing bugs by stepping through execution paths becomes impractical. Developers and their tooling will instead need to master the art of diagnosing issues through emergent symptoms. As Vijaye observes: “I think in a few years we'll get to the point where software um is is so complex software has gotten like so many layers in it and we get really good at identifying issues by looking at symptoms and our tools are going to get like really good at that too.” Interpreting these holistic behavioral clues will emerge as an essential, specialized capability for developers in the AI era.
[29:41](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1781s) A Dedicated Personal Assistant to Coordinate Swarms of AI Agents
Before the session concludes, Tibo jumps in with one final prediction regarding how engineers will interface with their automated tools on a day-to-day basis. Instead of forcing developers to individually supervise, monitor, and query 100 or 200 autonomous agents operating across various tasks, workflows will consolidate into a single primary interface. Developers will simply interact with one dedicated assistant that coordinates the entire fleet behind the scenes and reports back on high-level progress. As Tibo puts it: “I think very much you will just be able to call your assistant and check on the work as well and you know you will have like one dedicated sort of like personal assistant that is able to represent the work of like you know all the AI agents that are sort of like doing things for you productively behind the scenes instead of having like to monitor and like you know check in with like a hundred or like you know 200 individual like little agents.” He expects this unified model of agent management to arrive remarkably fast, anticipating its emergence within the year.
The host closes out the conversation by thanking Vijaye and Tibo for offering an authentic look into how OpenAI’s teams operate internally. He notes that the engineering realities and forward-looking practices developing inside OpenAI feel weeks, months, or even further ahead of where the broader industry currently sits, painting a vivid picture of the exciting, rapid transformation reshaping software engineering.
## Notable quotes > [18:25](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=1105s) As long as we're building products for humans to use, we will need human designers, we will need human product managers. — Vijaye Raji
> [12:07](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=727s) I actually truly believe that the new software engineers that are being created are going to be AI native. — Vijaye Raji
> [04:52](https://www.youtube.com/watch?v=Bo6Gtq3nMXc&t=292s) I actually think it's more fun now building software because the gratification cycle is so much shorter. — Vijaye Raji
## Mentioned OpenAI, Codex, Codex Box, Tibo Sottiaux, Vijaye Raji, Gergely Orosz, The Pragmatic Engineer, Alexander Embiricos, Linear, Notion, Microsoft, Visual Studio, IntelliSense, 1Password, Figma, Excel, PowerPoint, Slack, X, Reddit, Jira, ffmpeg
## Video description Tibo Sottiaux (Head of Engineering, Codex, OpenAI) and Vijaye Raji (CTO of Applications, OpenAI) at The Pragmatic Summit: www.pragmaticsummit.com. Watch sessions, with Q&A: https://newsletter.pragmaticengineer.com/p/the-pragmatic-summit-recordings
0:00 Intro: What’s changing inside OpenAI 0:54 Codex as teammate 3:13 How the Codex team works day-to-day 6:43 New engineering practices 12:07 New grads 16:37 The "new" software engineering role 18:25 PMs and designers 22:52 Token costs 26:50 Predicting the future
[Source](https://www.youtube.com/watch?v=Bo6Gtq3nMXc)