Greg Brockman and the end of the dev who writes semicolons: what OpenAI's bet changes in your code

In the interview published by Stratechery on September 4, 2026, Ben Thompson spoke with Greg Brockman, president and co-founder of OpenAI, recorded shortly before the announcement of Astra, the company's new multimodal model. Most of the conversation covers biography (Stripe, OpenAI's early years, the 2023 drama) and topics such as strategy, alignment, and the security incident involving Hugging Face. For those who build software, however, there's one statement worth more than the launch itself, and that's what this piece focuses on.

Brockman's thesis: the dev stops writing syntax

Brockman is known for hours-long coding sessions, including the 24-hour sprint that got Stripe onto the card networks (an integration that "should have taken nine months" and shipped overnight, according to him). That's exactly why his statement about the future of the profession carries weight. Speaking about his own transition from programmer to a leader who is no longer "hands on keyboard," he generalizes it to the entire category:

We're all moving away from being the person who knows exactly which library to use and can craft the syntax and where the semicolons go. We're all becoming higher-level managers, directors, the source of inspiration, vision, judgment, feedback.

>

-- Greg Brockman, president of OpenAI, to Stratechery

He frames this as "an important lesson for pretty much every software engineer right now" and says the shift will intensify over the next year. It's an honest statement about a real pain point, but it must be read for what it is: the worldview of an executive whose company's business depends precisely on this prophecy coming true. OpenAI sells the model that would supposedly replace writing syntax. The statement isn't neutral, it's the firm's investment thesis said out loud.

Why this isn't just stage talk

What backs up Brockman's statement isn't rhetoric, it's where the industry is putting its money. Astra is multimodal (text, image, the ability to "look" at visual content), and the central bet of the current generation of coding tools, from Copilot to Cursor, is to raise the level of abstraction at which the dev interacts with the machine. The promise is the same one Brockman describes: you specify intent, the model materializes the implementation.

In practice, much of this is already happening partially. Anyone using a coding agent today spends less time remembering a function's signature and more time reviewing what the tool proposed, deciding on architecture, and defining what's acceptable. Brockman's point is that this share grows until it becomes the entire job.

It's worth noting a detail from his own biography: Brockman learned to code on W3Schools, reading tutorials on HTML, JavaScript, CSS, and PHP, and the first thing he built was a widget that sorted table columns. It's a learning path that necessarily went through syntax. The open question, one the interview doesn't resolve, is how the "AI director" who never needed to understand the under the hood of the code they now direct gets formed.

The counterpoint the statement hides

The thesis has a hole that Brockman himself hands over in another part of the conversation, when talking about Stripe. He describes the value of "deeply understanding a domain you're not familiar with" in order to "expose the right primitives, the right APIs, the right abstractions." Card networks, he recalls, run on ISO 8583, a byte-oriented format from the 1980s. It was understanding that low-level complexity that allowed Stripe to build the simple abstraction on top.

Here's the contradiction that matters for decision-makers: the architectural judgment Brockman positions as the future of the profession historically comes from having struggled with syntax and domain details. The "director" he describes is only a good director because he was once the programmer who knew where the semicolons went. If the next generation skips that stage, where does the judgment come from to validate what the model spits out?

For the team building the product, the implication is concrete. Reviewing AI-generated code becomes the core competency, not an extra. Knowing how to read what an agent produced, identifying the security flaw it introduced, deciding whether the proposed abstraction will scale: this requires more fundamentals knowledge, not less. The interview, in fact, dedicates an entire section to security and the Hugging Face incident, which reinforces that blindly trusting the model's output is exactly where the risk lies.

What to do with this in Brazil

For Brazilian devs and tech leaders, the practical takeaway is to separate OpenAI's business thesis from what's already verifiable in your own workflow:

• What has already changed: less time memorizing syntax and API signatures, more time specifying intent and reviewing output. This is measurable in your own day-to-day right now, with today's tools.
• What's still a bet: that the dev can operate as a "director" without a solid foundation in fundamentals. There's no evidence of this in the interview, only the projection of an interested executive.
• Where it's not worth outsourcing judgment: security, stateful system architecture, and critical integrations, the equivalents of ISO 8583 in your domain. That's where the cost of accepting the model's wrong suggestion is highest.

There's also a cost angle that the stage talk ignores and that matters to whoever allocates the budget: running multimodal models like Astra in a development loop has a price, and the return depends on the "director" being good enough for review to be faster than writing the code by hand. On junior teams, that math may not add up.

The honest reading of the interview, then, isn't "devs will stop programming." It's that the expensive, scarce part of the job is migrating from the keyboard to judgment, and that the company most interested in accelerating this migration is the same one selling the tool. Those building tech businesses in Brazil do well to adopt the tools, demand real productivity gains, and keep training people who understand what runs underneath. Because, as Brockman's own trajectory shows, the good director is the programmer who once read the 1980s spec.

The full interview, including the sections on AGI, the AI value chain, and the security incident, is available on Stratechery.